Gitiles
Code Review Sign In
review.mlplatform.org / ml / armnn / 120522aee38d756f9c963e1b5b4da12b66ac5a40 / . / src / backends / reference / RefLayerSupport.cpp
blob: fbe235dcf2127f3f473f7e79d465ac14fdfa5751 [file] [log] [blame]
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]1//
2// Copyright © 2017 Arm Ltd. All rights reserved.
David Beckecb56cd2018-09-05 12:52:57 +0100[diff] [blame]3// SPDX-License-Identifier: MIT
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]4//
5
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]6#include "RefLayerSupport.hpp"
David Beck3e9e1152018-10-17 14:17:50 +0100[diff] [blame]7#include "RefBackendId.hpp"
David Beck3cc9a622018-10-12 10:38:31 +0100[diff] [blame]8
Aron Virginas-Tarc9cc8042018-11-01 16:15:57 +0000[diff] [blame]9#include <InternalTypes.hpp>
10#include <LayerSupportCommon.hpp>
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]11#include <armnn/Types.hpp>
Derek Lamberti50db4e82019-03-13 14:16:15 +0000[diff] [blame]12#include <armnn/Descriptors.hpp>
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]13
David Beck111b5d92018-11-12 14:59:37 +0000[diff] [blame]14#include <backendsCommon/BackendRegistry.hpp>
Francis Murtagh46c09d02019-05-28 08:15:28 +0100[diff] [blame]15#include <backendsCommon/test/WorkloadTestUtils.hpp>
David Beck3e9e1152018-10-17 14:17:50 +0100[diff] [blame]16
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]17#include <boost/core/ignore_unused.hpp>
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]18
Derek Lamberti50db4e82019-03-13 14:16:15 +0000[diff] [blame]19#include <vector>
20#include <algorithm>
21#include <array>
22
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]23using namespace boost;
24
25namespace armnn
26{
27
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]28namespace
29{
30
31template<typename Float32Func, typename Uint8Func, typename ... Params>
32bool IsSupportedForDataTypeRef(Optional<std::string&> reasonIfUnsupported,
33 DataType dataType,
34 Float32Func floatFuncPtr,
35 Uint8Func uint8FuncPtr,
36 Params&&... params)
37{
38 return IsSupportedForDataTypeGeneric(reasonIfUnsupported,
39 dataType,
40 &FalseFunc<Params...>,
41 floatFuncPtr,
42 uint8FuncPtr,
narpra01db2b1602019-01-23 15:23:11 +0000[diff] [blame]43 &FalseFunc<Params...>,
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame]44 &FalseFunc<Params...>,
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]45 std::forward<Params>(params)...);
46}
47
48} // anonymous namespace
49
Derek Lamberti50db4e82019-03-13 14:16:15 +0000[diff] [blame]50
51namespace
52{
53template<typename F>
54bool CheckSupportRule(F rule, Optional<std::string&> reasonIfUnsupported, const char* reason)
55{
56 bool supported = rule();
57 if (!supported && reason)
58 {
59 reasonIfUnsupported.value() += std::string(reason) + "\n"; // Append the reason on a new line
60 }
61 return supported;
62}
63
64struct Rule
65{
66 bool operator()() const
67 {
68 return m_Res;
69 }
70
71 bool m_Res = true;
72};
73
Derek Lamberti2a434a82019-03-20 13:07:57 +0000[diff] [blame]74template<typename T>
75bool AllTypesAreEqualImpl(T t)
Derek Lamberti50db4e82019-03-13 14:16:15 +0000[diff] [blame]76{
77 return true;
78}
79
80template<typename T, typename... Rest>
81bool AllTypesAreEqualImpl(T t1, T t2, Rest... rest)
82{
83 static_assert(std::is_same<T, TensorInfo>::value, "Type T must be a TensorInfo");
84
Derek Lamberti2a434a82019-03-20 13:07:57 +0000[diff] [blame]85 return (t1.GetDataType() == t2.GetDataType()) && AllTypesAreEqualImpl(t2, rest...);
Derek Lamberti50db4e82019-03-13 14:16:15 +0000[diff] [blame]86}
87
88struct TypesAreEqual : public Rule
89{
90 template<typename ... Ts>
91 TypesAreEqual(const Ts&... ts)
92 {
93 m_Res = AllTypesAreEqualImpl(ts...);
94 }
95};
96
97struct QuantizationParametersAreEqual : public Rule
98{
99 QuantizationParametersAreEqual(const TensorInfo& info0, const TensorInfo& info1)
100 {
101 m_Res = info0.GetQuantizationScale() == info1.GetQuantizationScale() &&
102 info0.GetQuantizationOffset() == info1.GetQuantizationOffset();
103 }
104};
105
106struct TypeAnyOf : public Rule
107{
108 template<typename Container>
109 TypeAnyOf(const TensorInfo& info, const Container& c)
110 {
111 m_Res = std::any_of(c.begin(), c.end(), [&info](DataType dt)
Francis Murtagh46c09d02019-05-28 08:15:28 +0100[diff] [blame]112 {
113 return dt == info.GetDataType();
114 });
115 }
116};
117
118struct BiasAndWeightsTypesMatch : public Rule
119{
120 BiasAndWeightsTypesMatch(const TensorInfo& biases, const TensorInfo& weights)
121 {
122 m_Res = biases.GetDataType() == GetBiasTypeFromWeightsType(weights.GetDataType()).value();
123 }
124};
125
126struct BiasAndWeightsTypesCompatible : public Rule
127{
128 template<typename Container>
129 BiasAndWeightsTypesCompatible(const TensorInfo& info, const Container& c)
130 {
131 m_Res = std::any_of(c.begin(), c.end(), [&info](DataType dt)
132 {
133 return dt == GetBiasTypeFromWeightsType(info.GetDataType()).value();
134 });
Derek Lamberti50db4e82019-03-13 14:16:15 +0000[diff] [blame]135 }
136};
137
138struct ShapesAreSameRank : public Rule
139{
140 ShapesAreSameRank(const TensorInfo& info0, const TensorInfo& info1)
141 {
142 m_Res = info0.GetShape().GetNumDimensions() == info1.GetShape().GetNumDimensions();
143 }
144};
145
Derek Lamberti5f400d62019-03-25 15:41:58 +0000[diff] [blame]146struct ShapesAreSameTotalSize : public Rule
147{
148 ShapesAreSameTotalSize(const TensorInfo& info0, const TensorInfo& info1)
149 {
150 m_Res = info0.GetNumElements() == info1.GetNumElements();
151 }
152};
153
Derek Lamberti50db4e82019-03-13 14:16:15 +0000[diff] [blame]154struct ShapesAreBroadcastCompatible : public Rule
155{
156 unsigned int CalcInputSize(const TensorShape& in, const TensorShape& out, unsigned int idx)
157 {
158 unsigned int offset = out.GetNumDimensions() - in.GetNumDimensions();
159 unsigned int sizeIn = (idx < offset) ? 1 : in[idx-offset];
160 return sizeIn;
161 }
162
163 ShapesAreBroadcastCompatible(const TensorInfo& in0, const TensorInfo& in1, const TensorInfo& out)
164 {
165 const TensorShape& shape0 = in0.GetShape();
166 const TensorShape& shape1 = in1.GetShape();
167 const TensorShape& outShape = out.GetShape();
168
169 for (unsigned int i=0; i < outShape.GetNumDimensions() && m_Res; i++)
170 {
171 unsigned int sizeOut = outShape[i];
172 unsigned int sizeIn0 = CalcInputSize(shape0, outShape, i);
173 unsigned int sizeIn1 = CalcInputSize(shape1, outShape, i);
174
175 m_Res &= ((sizeIn0 == sizeOut) || (sizeIn0 == 1)) &&
176 ((sizeIn1 == sizeOut) || (sizeIn1 == 1));
177 }
178 }
179};
180} // namespace
181
182
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]183bool RefLayerSupport::IsActivationSupported(const TensorInfo& input,
184 const TensorInfo& output,
185 const ActivationDescriptor& descriptor,
186 Optional<std::string&> reasonIfUnsupported) const
187{
Derek Lamberti50db4e82019-03-13 14:16:15 +0000[diff] [blame]188 bool supported = true;
189
190 // Define supported types.
Teresa Charlin18515e22019-04-24 10:17:46 +0100[diff] [blame]191 std::array<DataType,3> supportedTypes = {
Derek Lamberti50db4e82019-03-13 14:16:15 +0000[diff] [blame]192 DataType::Float32,
Teresa Charlin18515e22019-04-24 10:17:46 +0100[diff] [blame]193 DataType::QuantisedAsymm8,
194 DataType::QuantisedSymm16
Derek Lamberti50db4e82019-03-13 14:16:15 +0000[diff] [blame]195 };
196
197 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
198 "Reference activation: input type not supported.");
199
200 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
201 "Reference activation: output type not supported.");
202
203 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
204 "Reference activation: input and output types mismatched.");
205
206 supported &= CheckSupportRule(ShapesAreSameRank(input, output), reasonIfUnsupported,
207 "Reference activation: input and output shapes are of different rank.");
208
209
210 struct ActivationFunctionSupported : public Rule
211 {
212 ActivationFunctionSupported(const ActivationDescriptor& desc)
213 {
214 switch(desc.m_Function)
215 {
216 case ActivationFunction::Abs:
217 case ActivationFunction::BoundedReLu:
218 case ActivationFunction::LeakyReLu:
219 case ActivationFunction::Linear:
220 case ActivationFunction::ReLu:
221 case ActivationFunction::Sigmoid:
222 case ActivationFunction::SoftReLu:
223 case ActivationFunction::Sqrt:
224 case ActivationFunction::Square:
225 case ActivationFunction::TanH:
226 {
227 m_Res = true;
228 break;
229 }
230 default:
231 {
232 m_Res = false;
233 break;
234 }
235 }
236 }
237 };
238
239 // Function is supported
240 supported &= CheckSupportRule(ActivationFunctionSupported(descriptor), reasonIfUnsupported,
241 "Reference activation: function not supported.");
242
243 return supported;
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]244}
245
246bool RefLayerSupport::IsAdditionSupported(const TensorInfo& input0,
247 const TensorInfo& input1,
248 const TensorInfo& output,
249 Optional<std::string&> reasonIfUnsupported) const
250{
Derek Lamberti50db4e82019-03-13 14:16:15 +0000[diff] [blame]251 bool supported = true;
252
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]253 std::array<DataType,3> supportedTypes = {
Derek Lamberti50db4e82019-03-13 14:16:15 +0000[diff] [blame]254 DataType::Float32,
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]255 DataType::QuantisedAsymm8,
256 DataType::QuantisedSymm16
Derek Lamberti50db4e82019-03-13 14:16:15 +0000[diff] [blame]257 };
258
259 supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
260 "Reference addition: input 0 is not a supported type.");
261
262 supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
263 "Reference addition: input 1 is not a supported type.");
264
265 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
266 "Reference addition: output is not a supported type.");
267
268 supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
269 "Reference addition: input 0 and Input 1 types are mismatched");
270
271 supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
272 "Reference addition: input and output types are mismatched");
273
274 supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
275 "Reference addition: shapes are not suitable for implicit broadcast.");
276
277 return supported;
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]278}
279
280bool RefLayerSupport::IsBatchNormalizationSupported(const TensorInfo& input,
281 const TensorInfo& output,
282 const TensorInfo& mean,
283 const TensorInfo& var,
284 const TensorInfo& beta,
285 const TensorInfo& gamma,
286 const BatchNormalizationDescriptor& descriptor,
287 Optional<std::string&> reasonIfUnsupported) const
288{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]289 ignore_unused(output);
290 ignore_unused(mean);
291 ignore_unused(var);
292 ignore_unused(beta);
293 ignore_unused(gamma);
294 ignore_unused(descriptor);
295 return IsSupportedForDataTypeRef(reasonIfUnsupported,
296 input.GetDataType(),
297 &TrueFunc<>,
298 &TrueFunc<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]299}
300
Éanna Ó Catháin4e1e1362018-11-12 11:36:34 +0000[diff] [blame]301bool RefLayerSupport::IsBatchToSpaceNdSupported(const TensorInfo& input,
302 const TensorInfo& output,
303 const BatchToSpaceNdDescriptor& descriptor,
304 Optional<std::string&> reasonIfUnsupported) const
305{
306 ignore_unused(descriptor);
307 return (IsSupportedForDataTypeRef(reasonIfUnsupported,
308 input.GetDataType(),
309 &TrueFunc<>,
310 &TrueFunc<>) &&
311 IsSupportedForDataTypeRef(reasonIfUnsupported,
312 output.GetDataType(),
313 &TrueFunc<>,
314 &TrueFunc<>));
315}
316
Jim Flynn906f9462019-05-10 13:55:21 +0100[diff] [blame]317bool RefLayerSupport::IsConcatSupported(const std::vector<const TensorInfo*> inputs,
318 const TensorInfo& output,
Jim Flynne242f2d2019-05-22 14:24:13 +0100[diff] [blame]319 const ConcatDescriptor& descriptor,
Jim Flynn906f9462019-05-10 13:55:21 +0100[diff] [blame]320 Optional<std::string&> reasonIfUnsupported) const
321{
Jim Flynne242f2d2019-05-22 14:24:13 +0100[diff] [blame]322 ignore_unused(descriptor);
323
324 bool supported = true;
325 std::array<DataType,3> supportedTypes =
326 {
327 DataType::Float32,
328 DataType::QuantisedAsymm8,
329 DataType::QuantisedSymm16
330 };
331
332 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
333 "Reference concatenation: output type not supported");
334 for (const TensorInfo* input : inputs)
335 {
336 supported &= CheckSupportRule(TypeAnyOf(*input, supportedTypes), reasonIfUnsupported,
337 "Reference concatenation: input type not supported");
338
339 supported &= CheckSupportRule(TypesAreEqual(*input, output), reasonIfUnsupported,
340 "Reference concatenation: input and output types mismatched.");
341 }
342
343 return supported;
Jim Flynn906f9462019-05-10 13:55:21 +0100[diff] [blame]344}
345
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]346bool RefLayerSupport::IsConstantSupported(const TensorInfo& output,
347 Optional<std::string&> reasonIfUnsupported) const
348{
Jim Flynne242f2d2019-05-22 14:24:13 +0100[diff] [blame]349 std::array<DataType,4> supportedTypes =
350 {
Nina Drozd58ef2c62019-05-16 12:09:18 +0100[diff] [blame]351 DataType::Float32,
352 DataType::Signed32,
353 DataType::QuantisedAsymm8,
354 DataType::QuantisedSymm16
355 };
356
357 return CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
358 "Reference constant: output is not a supported type.");
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]359}
360
361bool RefLayerSupport::IsConvertFp16ToFp32Supported(const TensorInfo& input,
362 const TensorInfo& output,
363 Optional<std::string&> reasonIfUnsupported) const
364{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]365 return (IsSupportedForDataTypeGeneric(reasonIfUnsupported,
366 input.GetDataType(),
367 &TrueFunc<>,
368 &FalseInputFuncF32<>,
narpra01db2b1602019-01-23 15:23:11 +0000[diff] [blame]369 &FalseFuncU8<>,
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame]370 &FalseFuncI32<>,
371 &FalseFuncU8<>) &&
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]372 IsSupportedForDataTypeGeneric(reasonIfUnsupported,
373 output.GetDataType(),
374 &FalseOutputFuncF16<>,
375 &TrueFunc<>,
narpra01db2b1602019-01-23 15:23:11 +0000[diff] [blame]376 &FalseFuncU8<>,
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame]377 &FalseFuncI32<>,
378 &FalseFuncU8<>));
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]379}
380
381bool RefLayerSupport::IsConvertFp32ToFp16Supported(const TensorInfo& input,
382 const TensorInfo& output,
383 Optional<std::string&> reasonIfUnsupported) const
384{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]385 return (IsSupportedForDataTypeGeneric(reasonIfUnsupported,
386 input.GetDataType(),
387 &FalseInputFuncF16<>,
388 &TrueFunc<>,
narpra01db2b1602019-01-23 15:23:11 +0000[diff] [blame]389 &FalseFuncU8<>,
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame]390 &FalseFuncI32<>,
391 &FalseFuncU8<>) &&
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]392 IsSupportedForDataTypeGeneric(reasonIfUnsupported,
393 output.GetDataType(),
394 &TrueFunc<>,
395 &FalseOutputFuncF32<>,
narpra01db2b1602019-01-23 15:23:11 +0000[diff] [blame]396 &FalseFuncU8<>,
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame]397 &FalseFuncI32<>,
398 &FalseFuncU8<>));
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]399}
400
401bool RefLayerSupport::IsConvolution2dSupported(const TensorInfo& input,
402 const TensorInfo& output,
403 const Convolution2dDescriptor& descriptor,
404 const TensorInfo& weights,
405 const Optional<TensorInfo>& biases,
406 Optional<std::string&> reasonIfUnsupported) const
407{
Mike Kelly2f80f6e2019-05-16 12:41:34 +0100[diff] [blame]408 bool supported = true;
409
410 // Define supported types.
411 std::array<DataType,3> supportedTypes = {
412 DataType::Float32,
413 DataType::QuantisedAsymm8,
414 DataType::QuantisedSymm16
415 };
416
417 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
Les Belld7f29082019-05-30 09:08:51 +0100[diff] [blame]418 "Reference convolution2d: input is not a supported type.");
Mike Kelly2f80f6e2019-05-16 12:41:34 +0100[diff] [blame]419
420 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
Les Belld7f29082019-05-30 09:08:51 +0100[diff] [blame]421 "Reference convolution2d: output is not a supported type.");
Mike Kelly2f80f6e2019-05-16 12:41:34 +0100[diff] [blame]422
423 supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
Les Belld7f29082019-05-30 09:08:51 +0100[diff] [blame]424 "Reference convolution2d: weights is not a supported type.");
Mike Kelly2f80f6e2019-05-16 12:41:34 +0100[diff] [blame]425
426 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
Les Belld7f29082019-05-30 09:08:51 +0100[diff] [blame]427 "Reference convolution2d: input and output types mismatched.");
Mike Kelly2f80f6e2019-05-16 12:41:34 +0100[diff] [blame]428
429 supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
Les Belld7f29082019-05-30 09:08:51 +0100[diff] [blame]430 "Reference convolution2d: input and weights types mismatched.");
Mike Kelly2f80f6e2019-05-16 12:41:34 +0100[diff] [blame]431
432 if (biases.has_value())
433 {
434 std::array<DataType,3> biasesSupportedTypes = {
435 DataType::Float32,
436 DataType::Signed32
437 };
438 supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
Les Belld7f29082019-05-30 09:08:51 +0100[diff] [blame]439 "Reference convolution2d: biases is not a supported type.");
Mike Kelly2f80f6e2019-05-16 12:41:34 +0100[diff] [blame]440 }
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]441 ignore_unused(descriptor);
Mike Kelly2f80f6e2019-05-16 12:41:34 +0100[diff] [blame]442
443 return supported;
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]444}
445
Nattapat Chaimanowongcfdcadf2018-12-06 11:54:33 +0000[diff] [blame]446bool RefLayerSupport::IsDebugSupported(const TensorInfo& input,
447 const TensorInfo& output,
Nattapat Chaimanowongcfdcadf2018-12-06 11:54:33 +0000[diff] [blame]448 Optional<std::string&> reasonIfUnsupported) const
449{
450 ignore_unused(output);
Nattapat Chaimanowongcfdcadf2018-12-06 11:54:33 +0000[diff] [blame]451 return IsSupportedForDataTypeRef(reasonIfUnsupported,
452 input.GetDataType(),
453 &TrueFunc<>,
454 &TrueFunc<>);
455}
456
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]457bool RefLayerSupport::IsDepthwiseConvolutionSupported(const TensorInfo& input,
458 const TensorInfo& output,
459 const DepthwiseConvolution2dDescriptor& descriptor,
460 const TensorInfo& weights,
461 const Optional<TensorInfo>& biases,
462 Optional<std::string&> reasonIfUnsupported) const
463{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]464 ignore_unused(output);
465 ignore_unused(descriptor);
466 ignore_unused(weights);
467 ignore_unused(biases);
468 return IsSupportedForDataTypeRef(reasonIfUnsupported,
469 input.GetDataType(),
470 &TrueFunc<>,
471 &TrueFunc<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]472}
473
Nattapat Chaimanowong8a54ac02019-03-29 15:25:04 +0000[diff] [blame]474bool RefLayerSupport::IsDequantizeSupported(const TensorInfo& input,
475 const TensorInfo& output,
476 Optional<std::string&> reasonIfUnsupported) const
477{
Nattapat Chaimanowongafa4e3a2019-04-02 11:41:45 +0100[diff] [blame]478 bool supported = true;
479
480 std::array<DataType,2> supportedInputTypes = {
481 DataType::QuantisedAsymm8,
482 DataType::QuantisedSymm16
483 };
484
485 supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
486 "Reference dequantize: input type not supported.");
487
488 std::array<DataType,2> supportedOutputTypes = {
489 DataType::Float32,
490 };
491
492 supported &= CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
493 "Reference dequantize: output type not supported.");
494
495 supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
496 "Reference dequantize: input and output shapes have different num total elements.");
497
498 return supported;
Nattapat Chaimanowong8a54ac02019-03-29 15:25:04 +0000[diff] [blame]499}
500
Narumol Prangnawaratbc67cef2019-01-31 15:31:54 +0000[diff] [blame]501bool RefLayerSupport::IsDetectionPostProcessSupported(const armnn::TensorInfo& input0,
502 const armnn::TensorInfo& input1,
503 const armnn::DetectionPostProcessDescriptor& descriptor,
504 armnn::Optional<std::string&> reasonIfUnsupported) const
505{
506 ignore_unused(input1);
507 return IsSupportedForDataTypeRef(reasonIfUnsupported,
508 input0.GetDataType(),
509 &TrueFunc<>,
510 &TrueFunc<>);
511}
512
Pablo Tellof0bd6832019-04-26 17:58:13 +0100[diff] [blame]513bool RefLayerSupport::IsDilatedDepthwiseConvolutionSupported(const TensorInfo& input,
514 const TensorInfo& output,
515 const DepthwiseConvolution2dDescriptor& descriptor,
516 const TensorInfo& weights,
517 const Optional<TensorInfo>& biases,
518 Optional<std::string&> reasonIfUnsupported) const
519{
520 if (descriptor.m_DilationY == 1 && descriptor.m_DilationY == 1)
521 {
522 return IsDepthwiseConvolutionSupported(input, output, descriptor, weights, biases, reasonIfUnsupported);
523 }
524 else
525 {
526 if (reasonIfUnsupported)
527 {
528 reasonIfUnsupported.value() = "Reference Depthwise Convolution: Dilation parameters must be 1";
529 }
530 return false;
531 }
532}
533
534
535 bool RefLayerSupport::IsDivisionSupported(const TensorInfo& input0,
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]536 const TensorInfo& input1,
537 const TensorInfo& output,
538 Optional<std::string&> reasonIfUnsupported) const
539{
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]540 bool supported = true;
541
542 std::array<DataType,3> supportedTypes = {
543 DataType::Float32,
544 DataType::QuantisedAsymm8,
545 DataType::QuantisedSymm16
546 };
547
548 supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
549 "Reference division: input 0 is not a supported type.");
550
551 supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
552 "Reference division: input 1 is not a supported type.");
553
554 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
555 "Reference division: output is not a supported type.");
556
557 supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
558 "Reference division: input 0 and Input 1 types are mismatched");
559
560 supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
561 "Reference division: input and output types are mismatched");
562
563 supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
564 "Reference division: shapes are not suitable for implicit broadcast.");
565
566 return supported;
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]567}
568
FrancisMurtagh30cdfca2018-12-18 12:57:35 +0000[diff] [blame]569bool RefLayerSupport::IsEqualSupported(const TensorInfo& input0,
570 const TensorInfo& input1,
571 const TensorInfo& output,
572 Optional<std::string&> reasonIfUnsupported) const
573{
574 ignore_unused(input0);
575 ignore_unused(input1);
576 ignore_unused(output);
577 ignore_unused(reasonIfUnsupported);
578 return IsSupportedForDataTypeRef(reasonIfUnsupported,
579 input0.GetDataType(),
580 &TrueFunc<>,
581 &TrueFunc<>);
582}
583
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]584bool RefLayerSupport::IsFakeQuantizationSupported(const TensorInfo& input,
585 const FakeQuantizationDescriptor& descriptor,
586 Optional<std::string&> reasonIfUnsupported) const
587{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]588 ignore_unused(descriptor);
589 return IsSupportedForDataTypeRef(reasonIfUnsupported,
590 input.GetDataType(),
591 &TrueFunc<>,
592 &FalseFuncU8<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]593}
594
595bool RefLayerSupport::IsFloorSupported(const TensorInfo& input,
596 const TensorInfo& output,
597 Optional<std::string&> reasonIfUnsupported) const
598{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]599 ignore_unused(output);
600 return IsSupportedForDataTypeRef(reasonIfUnsupported,
601 input.GetDataType(),
602 &TrueFunc<>,
603 &FalseFuncU8<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]604}
605
606bool RefLayerSupport::IsFullyConnectedSupported(const TensorInfo& input,
607 const TensorInfo& output,
608 const TensorInfo& weights,
609 const TensorInfo& biases,
610 const FullyConnectedDescriptor& descriptor,
611 Optional<std::string&> reasonIfUnsupported) const
612{
Francis Murtagh46c09d02019-05-28 08:15:28 +0100[diff] [blame]613 bool supported = true;
614
615 // Define supported types.
616 std::array<DataType,3> supportedTypes =
617 {
618 DataType::Float32,
619 DataType::QuantisedAsymm8,
620 DataType::QuantisedSymm16
621 };
622
623 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
624 "Reference Fully Connected: input type not supported.");
625
626 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
627 "Reference Fully Connected: output type not supported.");
628
629 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
630 "Reference Fully Connected: input and output types mismatched.");
631
632 supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
633 "Reference Fully Connected: weights type not supported.");
634
635 supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
636 "Reference Fully Connected: input and weight types mismatched.");
637
638 if (descriptor.m_BiasEnabled)
639 {
640 // Defined supported types for bias
641 std::array<DataType, 2>
642 supportedBiasTypes =
643 {
644 DataType::Float32,
645 DataType::Signed32
646 };
647
648 supported &= CheckSupportRule(TypeAnyOf(biases, supportedBiasTypes), reasonIfUnsupported,
649 "Reference Fully Connected: bias type not supported.");
650
651 supported &= CheckSupportRule(BiasAndWeightsTypesMatch(biases, weights), reasonIfUnsupported,
652 "Reference Fully Connected: bias and weight types mismatch.");
653
654 supported &= CheckSupportRule(BiasAndWeightsTypesCompatible(weights, supportedBiasTypes), reasonIfUnsupported,
655 "Reference Fully Connected: bias type inferred from weights is incompatible.");
656
657 }
658
659 return supported;
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]660}
661
narpra014951d842019-01-18 16:53:53 +0000[diff] [blame]662bool RefLayerSupport::IsGatherSupported(const armnn::TensorInfo& input0,
663 const armnn::TensorInfo& input1,
664 const armnn::TensorInfo& output,
665 armnn::Optional<std::string&> reasonIfUnsupported) const
666{
667 ignore_unused(input1);
668 ignore_unused(output);
669 return IsSupportedForDataTypeRef(reasonIfUnsupported,
670 input0.GetDataType(),
671 &TrueFunc<>,
672 &TrueFunc<>);
673}
674
FrancisMurtagh878f0232018-12-19 10:56:15 +0000[diff] [blame]675bool RefLayerSupport::IsGreaterSupported(const TensorInfo& input0,
676 const TensorInfo& input1,
677 const TensorInfo& output,
678 Optional<std::string&> reasonIfUnsupported) const
679{
680 ignore_unused(input0);
681 ignore_unused(input1);
682 ignore_unused(output);
683 ignore_unused(reasonIfUnsupported);
684 return IsSupportedForDataTypeRef(reasonIfUnsupported,
685 input0.GetDataType(),
686 &TrueFunc<>,
687 &TrueFunc<>);
688}
689
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]690bool RefLayerSupport::IsInputSupported(const TensorInfo& input,
691 Optional<std::string&> reasonIfUnsupported) const
692{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]693 return IsSupportedForDataTypeRef(reasonIfUnsupported,
694 input.GetDataType(),
695 &TrueFunc<>,
696 &TrueFunc<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]697}
698
699bool RefLayerSupport::IsL2NormalizationSupported(const TensorInfo& input,
700 const TensorInfo& output,
701 const L2NormalizationDescriptor& descriptor,
702 Optional<std::string&> reasonIfUnsupported) const
703{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]704 ignore_unused(output);
705 ignore_unused(descriptor);
706 return IsSupportedForDataTypeRef(reasonIfUnsupported,
707 input.GetDataType(),
708 &TrueFunc<>,
709 &FalseFuncU8<>);
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]710}
711
712bool RefLayerSupport::IsLstmSupported(const TensorInfo& input,
713 const TensorInfo& outputStateIn,
714 const TensorInfo& cellStateIn,
715 const TensorInfo& scratchBuffer,
716 const TensorInfo& outputStateOut,
717 const TensorInfo& cellStateOut,
718 const TensorInfo& output,
719 const LstmDescriptor& descriptor,
720 const TensorInfo& inputToForgetWeights,
721 const TensorInfo& inputToCellWeights,
722 const TensorInfo& inputToOutputWeights,
723 const TensorInfo& recurrentToForgetWeights,
724 const TensorInfo& recurrentToCellWeights,
725 const TensorInfo& recurrentToOutputWeights,
726 const TensorInfo& forgetGateBias,
727 const TensorInfo& cellBias,
728 const TensorInfo& outputGateBias,
729 const TensorInfo* inputToInputWeights,
730 const TensorInfo* recurrentToInputWeights,
731 const TensorInfo* cellToInputWeights,
732 const TensorInfo* inputGateBias,
733 const TensorInfo* projectionWeights,
734 const TensorInfo* projectionBias,
735 const TensorInfo* cellToForgetWeights,
736 const TensorInfo* cellToOutputWeights,
737 Optional<std::string&> reasonIfUnsupported) const
738{
telsoa01c577f2c2018-08-31 09:22:23 +0100[diff] [blame]739 ignore_unused(descriptor);
740 ignore_unused(inputToForgetWeights);
741 ignore_unused(inputToCellWeights);
742 ignore_unused(inputToOutputWeights);
743 ignore_unused(recurrentToForgetWeights);
744 ignore_unused(recurrentToCellWeights);
745 ignore_unused(recurrentToOutputWeights);
746 ignore_unused(forgetGateBias);
747 ignore_unused(cellBias);
748 ignore_unused(outputGateBias);
749 ignore_unused(inputToInputWeights);
750 ignore_unused(recurrentToInputWeights);
751 ignore_unused(cellToInputWeights);
752 ignore_unused(inputGateBias);
753 ignore_unused(projectionWeights);
754 ignore_unused(projectionBias);
755 ignore_unused(cellToForgetWeights);
756 ignore_unused(cellToOutputWeights);
Nattapat Chaimanowongeb2b3292019-05-07 12:02:30 +0100[diff] [blame]757
758 bool supported = true;
759
760 std::array<DataType,2> supportedTypes = {
Conor Kennedyb9971c92019-05-07 07:14:23 +0100[diff] [blame]761 DataType::Float32,
762 DataType::QuantisedSymm16
Nattapat Chaimanowongeb2b3292019-05-07 12:02:30 +0100[diff] [blame]763 };
764
765 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
766 "Reference Lstm: input is not a supported type.");
767
768 supported &= CheckSupportRule(TypesAreEqual(input, outputStateIn), reasonIfUnsupported,
769 "Reference Lstm: input and outputStateIn types are mismatched");
770
771 supported &= CheckSupportRule(TypesAreEqual(input, cellStateIn), reasonIfUnsupported,
772 "Reference Lstm: input and cellStateIn types are mismatched");
773
774 supported &= CheckSupportRule(TypesAreEqual(input, scratchBuffer), reasonIfUnsupported,
775 "Reference Lstm: input and scratchBuffer types are mismatched");
776
777 supported &= CheckSupportRule(TypesAreEqual(input, outputStateOut), reasonIfUnsupported,
778 "Reference Lstm: input and outputStateOut types are mismatched");
779
780 supported &= CheckSupportRule(TypesAreEqual(input, cellStateOut), reasonIfUnsupported,
781 "Reference Lstm: input and cellStateOut types are mismatched");
782
783 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
784 "Reference Lstm: input and output types are mismatched");
785
786 return supported;
telsoa01c577f2c2018-08-31 09:22:23 +0100[diff] [blame]787}
788
saoste012df12b32018-11-28 16:57:20 +0000[diff] [blame]789bool RefLayerSupport::IsMaximumSupported(const TensorInfo& input0,
790 const TensorInfo& input1,
791 const TensorInfo& output,
792 Optional<std::string&> reasonIfUnsupported) const
793{
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]794 bool supported = true;
795
796 std::array<DataType,3> supportedTypes = {
797 DataType::Float32,
798 DataType::QuantisedAsymm8,
799 DataType::QuantisedSymm16
800 };
801
802 supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
803 "Reference maximum: input 0 is not a supported type.");
804
805 supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
806 "Reference maximum: input 1 is not a supported type.");
807
808 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
809 "Reference maximum: output is not a supported type.");
810
811 supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
812 "Reference maximum: input 0 and Input 1 types are mismatched");
813
814 supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
815 "Reference maximum: input and output types are mismatched");
816
817 supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
818 "Reference maximum: shapes are not suitable for implicit broadcast.");
819
820 return supported;
saoste012df12b32018-11-28 16:57:20 +0000[diff] [blame]821}
822
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]823bool RefLayerSupport::IsMeanSupported(const TensorInfo& input,
824 const TensorInfo& output,
825 const MeanDescriptor& descriptor,
826 Optional<std::string&> reasonIfUnsupported) const
narpra0132b90462018-09-13 11:07:48 +0100[diff] [blame]827{
narpra011e4c31d2018-09-28 11:07:51 +0100[diff] [blame]828 ignore_unused(output);
829 ignore_unused(descriptor);
830 return IsSupportedForDataTypeRef(reasonIfUnsupported,
831 input.GetDataType(),
832 &TrueFunc<>,
833 &TrueFunc<>);
narpra0132b90462018-09-13 11:07:48 +0100[diff] [blame]834}
835
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]836bool RefLayerSupport::IsMergerSupported(const std::vector<const TensorInfo*> inputs,
Nikhil Raj8599a412018-11-19 14:51:07 +0000[diff] [blame]837 const TensorInfo& output,
Jim Flynne242f2d2019-05-22 14:24:13 +0100[diff] [blame]838 const MergerDescriptor& descriptor,
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]839 Optional<std::string&> reasonIfUnsupported) const
840{
Jim Flynne242f2d2019-05-22 14:24:13 +0100[diff] [blame]841 return IsConcatSupported(inputs, output, descriptor, reasonIfUnsupported);
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]842}
843
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]844bool RefLayerSupport::IsMemCopySupported(const TensorInfo &input,
845 const TensorInfo &output,
846 Optional<std::string &> reasonIfUnsupported) const
847{
848 ignore_unused(output);
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame]849 return IsSupportedForDataTypeGeneric(reasonIfUnsupported,
850 input.GetDataType(),
851 &TrueFunc<>,
852 &TrueFunc<>,
853 &TrueFunc<>,
854 &FalseFuncI32<>,
855 &TrueFunc<>);
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]856}
857
Éanna Ó Catháin20e58802018-12-04 10:29:06 +0000[diff] [blame]858bool RefLayerSupport::IsMinimumSupported(const TensorInfo& input0,
859 const TensorInfo& input1,
860 const TensorInfo& output,
861 Optional<std::string&> reasonIfUnsupported) const
862{
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]863 bool supported = true;
864
865 std::array<DataType,3> supportedTypes = {
866 DataType::Float32,
867 DataType::QuantisedAsymm8,
868 DataType::QuantisedSymm16
869 };
870
871 supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
872 "Reference minimum: input 0 is not a supported type.");
873
874 supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
875 "Reference minimum: input 1 is not a supported type.");
876
877 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
878 "Reference minimum: output is not a supported type.");
879
880 supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
881 "Reference minimum: input 0 and Input 1 types are mismatched");
882
883 supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
884 "Reference minimum: input and output types are mismatched");
885
886 supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
887 "Reference minimum: shapes are not suitable for implicit broadcast.");
888
889 return supported;
Éanna Ó Catháin20e58802018-12-04 10:29:06 +0000[diff] [blame]890}
891
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]892bool RefLayerSupport::IsMultiplicationSupported(const TensorInfo& input0,
893 const TensorInfo& input1,
894 const TensorInfo& output,
895 Optional<std::string&> reasonIfUnsupported) const
896{
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]897 bool supported = true;
898
899 std::array<DataType,3> supportedTypes = {
900 DataType::Float32,
901 DataType::QuantisedAsymm8,
902 DataType::QuantisedSymm16
903 };
904
905 supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
906 "Reference multiplication: input 0 is not a supported type.");
907
908 supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
909 "Reference multiplication: input 1 is not a supported type.");
910
911 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
912 "Reference multiplication: output is not a supported type.");
913
914 supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
915 "Reference multiplication: input 0 and Input 1 types are mismatched");
916
917 supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
918 "Reference multiplication: input and output types are mismatched");
919
920 supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
921 "Reference multiplication: shapes are not suitable for implicit broadcast.");
922
923 return supported;
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]924}
925
926bool RefLayerSupport::IsNormalizationSupported(const TensorInfo& input,
927 const TensorInfo& output,
928 const NormalizationDescriptor& descriptor,
929 Optional<std::string&> reasonIfUnsupported) const
Nina Drozd661dfa72018-10-02 11:14:17 +0100[diff] [blame]930{
931 ignore_unused(output);
932 ignore_unused(descriptor);
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]933 return IsSupportedForDataTypeRef(reasonIfUnsupported,
934 input.GetDataType(),
935 &TrueFunc<>,
936 &FalseFuncU8<>);
937}
938
939bool RefLayerSupport::IsOutputSupported(const TensorInfo& output,
940 Optional<std::string&> reasonIfUnsupported) const
941{
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame]942 return IsSupportedForDataTypeGeneric(reasonIfUnsupported,
943 output.GetDataType(),
944 &TrueFunc<>,
945 &TrueFunc<>,
946 &TrueFunc<>,
947 &FalseFuncI32<>,
948 &TrueFunc<>);
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]949}
950
951bool RefLayerSupport::IsPadSupported(const TensorInfo& input,
952 const TensorInfo& output,
953 const PadDescriptor& descriptor,
954 Optional<std::string&> reasonIfUnsupported) const
955{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]956 ignore_unused(output);
957 ignore_unused(descriptor);
jimfly01f6ba7472018-12-04 10:09:52 +0000[diff] [blame]958 return IsSupportedForDataTypeRef(reasonIfUnsupported,
959 input.GetDataType(),
960 &TrueFunc<>,
961 &TrueFunc<>);
Nina Drozd661dfa72018-10-02 11:14:17 +0100[diff] [blame]962}
963
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]964bool RefLayerSupport::IsPermuteSupported(const TensorInfo& input,
965 const TensorInfo& output,
966 const PermuteDescriptor& descriptor,
967 Optional<std::string&> reasonIfUnsupported) const
968{
969 ignore_unused(output);
970 ignore_unused(descriptor);
971 return IsSupportedForDataTypeRef(reasonIfUnsupported,
972 input.GetDataType(),
973 &TrueFunc<>,
974 &TrueFunc<>);
975}
976
977bool RefLayerSupport::IsPooling2dSupported(const TensorInfo& input,
978 const TensorInfo& output,
979 const Pooling2dDescriptor& descriptor,
980 Optional<std::string&> reasonIfUnsupported) const
981{
982 ignore_unused(output);
983 ignore_unused(descriptor);
984 return IsSupportedForDataTypeRef(reasonIfUnsupported,
985 input.GetDataType(),
986 &TrueFunc<>,
987 &TrueFunc<>);
988}
989
Derek Lamberti5f400d62019-03-25 15:41:58 +0000[diff] [blame]990bool RefLayerSupport::IsQuantizeSupported(const TensorInfo& input,
991 const TensorInfo& output,
992 Optional<std::string&> reasonIfUnsupported) const
993{
994 bool supported = true;
995
996 // Define supported output types.
997 std::array<DataType,2> supportedInputTypes = {
998 DataType::Float32,
999 };
1000
1001 supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
1002 "Reference quantize: input type not supported.");
1003
1004 // Define supported output types.
1005 std::array<DataType,2> supportedOutputTypes = {
1006 DataType::QuantisedAsymm8,
1007 DataType::QuantisedSymm16
1008 };
1009 supported &= CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
1010 "Reference quantize: output type not supported.");
1011
1012 supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
1013 "Reference quantize: input and output shapes have different num total elements.");
1014
1015 return supported;
1016}
1017
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1018bool RefLayerSupport::IsReshapeSupported(const TensorInfo& input,
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]1019 const ReshapeDescriptor& descriptor,
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1020 Optional<std::string&> reasonIfUnsupported) const
1021{
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]1022 ignore_unused(descriptor);
Nina Drozd2f2778f2019-05-27 10:37:05 +0100[diff] [blame]1023 // Define supported output types.
Nina Drozd8ed4b8c2019-05-29 10:41:04 +0100[diff] [blame]1024 std::array<DataType,4> supportedOutputTypes =
Nina Drozd2f2778f2019-05-27 10:37:05 +0100[diff] [blame]1025 {
1026 DataType::Float32,
1027 DataType::Float16,
Nina Drozd8ed4b8c2019-05-29 10:41:04 +0100[diff] [blame]1028 DataType::QuantisedAsymm8,
1029 DataType::QuantisedSymm16
Nina Drozd2f2778f2019-05-27 10:37:05 +0100[diff] [blame]1030 };
1031 return CheckSupportRule(TypeAnyOf(input, supportedOutputTypes), reasonIfUnsupported,
1032 "Reference reshape: input type not supported.");
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1033}
1034
1035bool RefLayerSupport::IsResizeBilinearSupported(const TensorInfo& input,
Sadik Armaganc625f002018-12-17 11:32:16 +0000[diff] [blame]1036 const TensorInfo& output,
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1037 Optional<std::string&> reasonIfUnsupported) const
1038{
Sadik Armaganc625f002018-12-17 11:32:16 +0000[diff] [blame]1039 ignore_unused(output);
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1040 return IsSupportedForDataTypeRef(reasonIfUnsupported,
1041 input.GetDataType(),
1042 &TrueFunc<>,
1043 &TrueFunc<>);
1044}
1045
Mohamed Nour Abouelseouda1d3c6a2018-12-27 12:39:16 +0000[diff] [blame]1046bool RefLayerSupport::IsRsqrtSupported(const TensorInfo& input,
1047 const TensorInfo& output,
1048 Optional<std::string&> reasonIfUnsupported) const
1049{
1050 ignore_unused(output);
1051 return IsSupportedForDataTypeRef(reasonIfUnsupported,
1052 input.GetDataType(),
1053 &TrueFunc<>,
1054 &FalseFuncU8<>);
1055}
1056
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1057bool RefLayerSupport::IsSoftmaxSupported(const TensorInfo& input,
1058 const TensorInfo& output,
1059 const SoftmaxDescriptor& descriptor,
1060 Optional<std::string&> reasonIfUnsupported) const
1061{
1062 ignore_unused(output);
nikraj01248683f2019-05-29 16:46:50 +0100[diff] [blame]1063 bool supported = true;
1064 std::array<DataType,3> supportedTypes =
1065 {
1066 DataType::Float32,
1067 DataType::QuantisedAsymm8,
1068 DataType::QuantisedSymm16
1069 };
1070
1071 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1072 "Reference concatenation: output type not supported");
1073
1074 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1075 "Reference concatenation: input type not supported");
1076
1077 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1078 "Reference concatenation: input type not supported");
1079
1080 return supported;
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1081}
1082
Nattapat Chaimanowong3ea76d52018-11-09 14:10:38 +0000[diff] [blame]1083bool RefLayerSupport::IsSpaceToBatchNdSupported(const TensorInfo& input,
1084 const TensorInfo& output,
1085 const SpaceToBatchNdDescriptor& descriptor,
1086 Optional<std::string&> reasonIfUnsupported) const
1087{
1088 ignore_unused(output);
nikraj01120522a2019-05-31 11:33:07 +0100[diff] [blame^]1089 bool supported = true;
1090 std::array<DataType,3> supportedTypes =
1091 {
1092 DataType::Float32,
1093 DataType::QuantisedAsymm8,
1094 DataType::QuantisedSymm16
1095 };
1096
1097 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1098 "Reference SpaceToBatchNd: input type not supported");
1099
1100 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1101 "Reference SpaceToBatchNd: output type not supported");
1102
1103 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1104 "Reference SpaceToBatchNd: input and output types are mismatched");
1105
1106 return supported;
Nattapat Chaimanowong3ea76d52018-11-09 14:10:38 +0000[diff] [blame]1107}
1108
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1109bool RefLayerSupport::IsSplitterSupported(const TensorInfo& input,
1110 const ViewsDescriptor& descriptor,
1111 Optional<std::string&> reasonIfUnsupported) const
1112{
1113 ignore_unused(descriptor);
1114 return IsSupportedForDataTypeRef(reasonIfUnsupported,
1115 input.GetDataType(),
1116 &TrueFunc<>,
1117 &TrueFunc<>);
1118}
1119
Narumol Prangnawarat15eb5832019-05-20 15:31:05 +0100[diff] [blame]1120bool RefLayerSupport::IsSplitterSupported(const TensorInfo& input,
1121 const std::vector<std::reference_wrapper<TensorInfo>>& outputs,
1122 const ViewsDescriptor& descriptor,
1123 Optional<std::string&> reasonIfUnsupported) const
1124{
1125 ignore_unused(descriptor);
1126 ignore_unused(outputs);
1127 return IsSupportedForDataTypeRef(reasonIfUnsupported,
1128 input.GetDataType(),
1129 &TrueFunc<>,
1130 &TrueFunc<>);
1131}
1132
Nattapat Chaimanowong1216b582018-11-23 15:33:41 +0000[diff] [blame]1133bool RefLayerSupport::IsStridedSliceSupported(const TensorInfo& input,
1134 const TensorInfo& output,
1135 const StridedSliceDescriptor& descriptor,
1136 Optional<std::string&> reasonIfUnsupported) const
1137{
1138 ignore_unused(output);
1139 ignore_unused(descriptor);
1140 return IsSupportedForDataTypeRef(reasonIfUnsupported,
1141 input.GetDataType(),
1142 &TrueFunc<>,
1143 &TrueFunc<>);
1144}
1145
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1146bool RefLayerSupport::IsSubtractionSupported(const TensorInfo& input0,
1147 const TensorInfo& input1,
1148 const TensorInfo& output,
1149 Optional<std::string&> reasonIfUnsupported) const
1150{
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]1151 bool supported = true;
1152
1153 std::array<DataType,3> supportedTypes = {
1154 DataType::Float32,
1155 DataType::QuantisedAsymm8,
1156 DataType::QuantisedSymm16
1157 };
1158
1159 supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1160 "Reference subtraction: input 0 is not a supported type.");
1161
1162 supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
1163 "Reference subtraction: input 1 is not a supported type.");
1164
1165 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1166 "Reference subtraction: output is not a supported type.");
1167
1168 supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
1169 "Reference subtraction: input 0 and Input 1 types are mismatched");
1170
1171 supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1172 "Reference subtraction: input and output types are mismatched");
1173
1174 supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
1175 "Reference subtraction: shapes are not suitable for implicit broadcast.");
1176
1177 return supported;
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1178}
1179
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]1180} // namespace armnn