From 8efb48a6847c5cd166c561127ae6611150963ce3 Mon Sep 17 00:00:00 2001 From: Nikhil Raj Date: Fri, 19 May 2023 11:14:28 +0100 Subject: Update Doxygen docu for 23.05 Signed-off-by: Nikhil Raj Change-Id: I0a992286f14fa68fcc6e5eba31ac39fed003cbbe --- 23.05/_neon_layer_support_8cpp_source.xhtml | 2152 +++++++++++++++++++++++++++ 1 file changed, 2152 insertions(+) create mode 100644 23.05/_neon_layer_support_8cpp_source.xhtml (limited to '23.05/_neon_layer_support_8cpp_source.xhtml') diff --git a/23.05/_neon_layer_support_8cpp_source.xhtml b/23.05/_neon_layer_support_8cpp_source.xhtml new file mode 100644 index 0000000000..fd5dd63c78 --- /dev/null +++ b/23.05/_neon_layer_support_8cpp_source.xhtml @@ -0,0 +1,2152 @@ + + + + + + + + + + + + + +ArmNN: src/backends/neon/NeonLayerSupport.cpp Source File + + + + + + + + + + + + + + + + +
+
+ + + + ArmNN + + + +
+
+  23.05 +
+
+
+ + + + + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+ +
+ +
+
+
NeonLayerSupport.cpp
+
+
+Go to the documentation of this file.
1 //
+
2 // Copyright © 2017-2023 Arm Ltd and Contributors. All rights reserved.
+
3 // SPDX-License-Identifier: MIT
+
4 //
+
5 
+
6 #include "NeonLayerSupport.hpp"
+
7 #include "NeonBackendId.hpp"
+
8 #include "NeonBackendModelContext.hpp"
+
9 
+
10 #include <armnn/Exceptions.hpp>
+
11 #include <armnn/Tensor.hpp>
+
12 #include <armnn/Types.hpp>
+
13 #include <armnn/BackendRegistry.hpp>
+
14 
+
15 #include <InternalTypes.hpp>
+
16 #include <LayerSupportCommon.hpp>
+
17 #include <armnn/utility/IgnoreUnused.hpp>
+
18 #include <armnn/utility/PolymorphicDowncast.hpp>
+
19 
+
20 #if defined(ARMCOMPUTENEON_ENABLED)
+
21 #include <aclCommon/ArmComputeUtils.hpp>
+
22 #include <aclCommon/ArmComputeTensorUtils.hpp>
+
23 #include "workloads/NeonAbsWorkload.hpp"
+
24 #include "workloads/NeonAdditionWorkload.hpp"
+
25 #include "workloads/NeonActivationWorkload.hpp"
+
26 #include "workloads/NeonArgMinMaxWorkload.hpp"
+
27 #include "workloads/NeonBatchMatMulWorkload.hpp"
+
28 #include "workloads/NeonBatchNormalizationWorkload.hpp"
+
29 #include "workloads/NeonBatchToSpaceNdWorkload.hpp"
+
30 #include "workloads/NeonCastWorkload.hpp"
+
31 #include "workloads/NeonChannelShuffleWorkload.hpp"
+
32 #include "workloads/NeonComparisonWorkload.hpp"
+
33 #include "workloads/NeonConcatWorkload.hpp"
+
34 #include "workloads/NeonConstantWorkload.hpp"
+
35 #include "workloads/NeonConvertFp16ToFp32Workload.hpp"
+
36 #include "workloads/NeonConvertFp32ToFp16Workload.hpp"
+
37 #include "workloads/NeonConvolution2dWorkload.hpp"
+
38 #include "workloads/NeonConvolution3dWorkload.hpp"
+
39 #include "workloads/NeonDepthToSpaceWorkload.hpp"
+
40 #include "workloads/NeonDepthwiseConvolutionWorkload.hpp"
+
41 #include "workloads/NeonDequantizeWorkload.hpp"
+
42 #include "workloads/NeonExpWorkload.hpp"
+
43 #include "workloads/NeonInstanceNormalizationWorkload.hpp"
+
44 #include "workloads/NeonL2NormalizationFloatWorkload.hpp"
+
45 #include "workloads/NeonLogWorkload.hpp"
+
46 #include "workloads/NeonLogSoftmaxWorkload.hpp"
+
47 #include "workloads/NeonLogicalAndWorkload.hpp"
+
48 #include "workloads/NeonLogicalNotWorkload.hpp"
+
49 #include "workloads/NeonLogicalOrWorkload.hpp"
+
50 #include "workloads/NeonLstmFloatWorkload.hpp"
+
51 #include "workloads/NeonMaximumWorkload.hpp"
+
52 #include "workloads/NeonMeanWorkload.hpp"
+
53 #include "workloads/NeonMinimumWorkload.hpp"
+
54 #include "workloads/NeonMultiplicationWorkload.hpp"
+
55 #include "workloads/NeonDivisionWorkload.hpp"
+
56 #include "workloads/NeonNegWorkload.hpp"
+
57 #include "workloads/NeonNormalizationFloatWorkload.hpp"
+
58 #include "workloads/NeonFullyConnectedWorkload.hpp"
+
59 #include "workloads/NeonGatherWorkload.hpp"
+
60 #include "workloads/NeonGatherNdWorkload.hpp"
+
61 #include "workloads/NeonPadWorkload.hpp"
+
62 #include "workloads/NeonPermuteWorkload.hpp"
+
63 #include "workloads/NeonPooling2dWorkload.hpp"
+
64 #include "workloads/NeonPooling3dWorkload.hpp"
+
65 #include "workloads/NeonPreluWorkload.hpp"
+
66 #include "workloads/NeonQLstmWorkload.hpp"
+
67 #include "workloads/NeonQuantizeWorkload.hpp"
+
68 #include "workloads/NeonQuantizedLstmWorkload.hpp"
+
69 #include "workloads/NeonReduceWorkload.hpp"
+
70 #include "workloads/NeonReshapeWorkload.hpp"
+
71 #include "workloads/NeonResizeWorkload.hpp"
+
72 #include "workloads/NeonRsqrtWorkload.hpp"
+
73 #include "workloads/NeonSinWorkload.hpp"
+
74 #include "workloads/NeonSliceWorkload.hpp"
+
75 #include "workloads/NeonSoftmaxWorkload.hpp"
+
76 #include "workloads/NeonSpaceToBatchNdWorkload.hpp"
+
77 #include "workloads/NeonSpaceToDepthWorkload.hpp"
+
78 #include "workloads/NeonSplitterWorkload.hpp"
+
79 #include "workloads/NeonSqrtWorkload.hpp"
+
80 #include "workloads/NeonStackWorkload.hpp"
+
81 #include "workloads/NeonStridedSliceWorkload.hpp"
+
82 #include "workloads/NeonSubtractionWorkload.hpp"
+
83 #include "workloads/NeonTransposeConvolution2dWorkload.hpp"
+
84 #include "workloads/NeonTransposeWorkload.hpp"
+
85 #include "workloads/NeonUnidirectionalSequenceLstmFloatWorkload.hpp"
+
86 #include "workloads/NeonUnidirectionalSequenceLstmWorkload.hpp"
+
87 #endif
+
88 
+
89 namespace armnn
+
90 {
+
91 
+
92 namespace
+
93 {
+
94 
+
95 const TensorInfo OverrideDataType(const TensorInfo& info, Optional<DataType> type)
+
96 {
+
97  if (!type)
+
98  {
+
99  return info;
+
100  }
+
101  return TensorInfo(info.GetShape(),
+
102  type.value(),
+
103  info.GetQuantizationScale(),
+
104  info.GetQuantizationOffset(),
+
105  info.IsConstant());
+
106 }
+
107 
+
108 template< typename ... Args>
+
109 bool IsNeonBackendSupported(Optional<std::string&> reasonIfUnsupported, Args... args)
+
110 {
+
111  IgnoreUnused(reasonIfUnsupported, (args)...);
+
112 #if defined(ARMCOMPUTENEON_ENABLED)
+
113  return true;
+
114 #else
+
115  SetValueChecked(reasonIfUnsupported, "The armnn library has been built without NEON support");
+
116  return false;
+
117 #endif
+
118 }
+
119 
+
120 template<typename FloatFunc, typename Uint8Func, typename ... Params>
+
121 bool IsSupportedForDataTypeNeon(Optional<std::string&> reasonIfUnsupported,
+
122  DataType dataType,
+
123  FloatFunc floatFuncPtr,
+
124  Uint8Func uint8FuncPtr,
+
125  Params&&... params)
+
126 {
+
127  return IsNeonBackendSupported(reasonIfUnsupported) &&
+
128  IsSupportedForDataTypeGeneric(reasonIfUnsupported,
+
129  dataType,
+
130  floatFuncPtr,
+
131  floatFuncPtr,
+
132  uint8FuncPtr,
+
133  &FalseFunc<>,
+
134  &FalseFunc<>,
+
135  std::forward<Params>(params)...);
+
136 }
+
137 
+
138 #if defined(ARMCOMPUTENEON_ENABLED)
+
139 template<class FuncType, class... Args>
+
140 inline bool IsWorkloadSupported(FuncType& func, Optional<std::string&> reasonIfUnsupported, Args&&... args)
+
141 {
+
142  arm_compute::Status aclStatus = func(std::forward<Args>(args)...);
+
143  const bool supported = (aclStatus.error_code() == arm_compute::ErrorCode::OK);
+
144  if (!supported && reasonIfUnsupported)
+
145  {
+
146  reasonIfUnsupported.value() = aclStatus.error_description();
+
147  }
+
148  return supported;
+
149 }
+
150 
+
151 #define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported, ...) \
+
152  return IsWorkloadSupported(func, reasonIfUnsupported, __VA_ARGS__);
+
153 #else
+
154 #define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported, ...) \
+
155  return IsNeonBackendSupported(reasonIfUnsupported, __VA_ARGS__);
+
156 #endif
+
157 } // anonymous namespace
+
158 
+
159 NeonLayerSupport::NeonLayerSupport(const IBackendInternal::IBackendSpecificModelContextPtr& modelContextPtr)
+
160  : m_ModelContextPtr(modelContextPtr)
+
161 {
+
162 }
+
163 
+
164 NeonLayerSupport::NeonLayerSupport()
+
165  : m_ModelContextPtr(nullptr)
+
166 {
+
167 }
+
168 
+
169 bool IsLayerTypeSupported(const LayerType& type,
+
170  const std::vector<TensorInfo>& infos,
+
171  const BaseDescriptor& descriptor,
+
172  const Optional<LstmInputParamsInfo>& lstmParamsInfo,
+
173  const Optional<QuantizedLstmInputParamsInfo>& quantizedLstmParamsInfo,
+
174  Optional<std::string&> reasonIfUnsupported,
+
175  const NeonLayerSupport& support)
+
176 {
+
177  switch (type)
+
178  {
+
179  case LayerType::Activation:
+
180  return support.IsActivationSupported(infos[0],
+
181  infos[1],
+
182  *(PolymorphicDowncast<const ActivationDescriptor*>(&descriptor)),
+
183  reasonIfUnsupported);
+
184  case LayerType::Addition:
+
185  return support.IsAdditionSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
+
186  case LayerType::ArgMinMax:
+
187  return support.IsArgMinMaxSupported(infos[0],
+
188  infos[1],
+
189  *(PolymorphicDowncast<const ArgMinMaxDescriptor*>(&descriptor)),
+
190  reasonIfUnsupported);
+
191  case LayerType::BatchMatMul:
+
192  return support.IsBatchMatMulSupported(infos[0],
+
193  infos[1],
+
194  infos[2],
+
195  *(PolymorphicDowncast<const BatchMatMulDescriptor*>(&descriptor)),
+
196  reasonIfUnsupported);
+
197  case LayerType::BatchNormalization:
+
198  return support.IsBatchNormalizationSupported(infos[0],
+
199  infos[1],
+
200  infos[2],
+
201  infos[3],
+
202  infos[4],
+
203  infos[5],
+
204  *(PolymorphicDowncast<const
+
205  BatchNormalizationDescriptor*>(&descriptor)),
+
206  reasonIfUnsupported);
+
207  case LayerType::BatchToSpaceNd:
+
208  return support.IsBatchToSpaceNdSupported(infos[0],
+
209  infos[1],
+
210  *(PolymorphicDowncast<const
+
211  BatchToSpaceNdDescriptor*>(&descriptor)),
+
212  reasonIfUnsupported);
+
213  case LayerType::Cast:
+
214  return support.IsCastSupported(infos[0], infos[1], reasonIfUnsupported);
+
215  case LayerType::ChannelShuffle:
+
216  return support.IsChannelShuffleSupported(infos[0],
+
217  infos[1],
+
218  *(PolymorphicDowncast<const
+
219  ChannelShuffleDescriptor*>(&descriptor)),
+
220  reasonIfUnsupported);
+
221  case LayerType::Comparison:
+
222  return support.IsComparisonSupported(infos[0],
+
223  infos[1],
+
224  infos[2],
+
225  *(PolymorphicDowncast<const ComparisonDescriptor*>(&descriptor)),
+
226  reasonIfUnsupported);
+
227  case LayerType::Concat:
+
228  {
+
229  std::vector<const TensorInfo*> inputInfos;
+
230  for (uint32_t i = 0; i < (infos.size() - 1); i++)
+
231  {
+
232  inputInfos.push_back(&infos[i]);
+
233  }
+
234  return support.IsConcatSupported(inputInfos,
+
235  infos[infos.size() - 1],
+
236  *(PolymorphicDowncast<const OriginsDescriptor*>(&descriptor)),
+
237  reasonIfUnsupported);
+
238  }
+
239  case LayerType::Constant:
+
240  return support.IsConstantSupported(infos[0], reasonIfUnsupported);
+
241  case LayerType::ConvertFp16ToFp32:
+
242  return support.IsConvertFp16ToFp32Supported(infos[0], infos[1], reasonIfUnsupported);
+
243  case LayerType::ConvertFp32ToFp16:
+
244  return support.IsConvertFp32ToFp16Supported(infos[0], infos[1], reasonIfUnsupported);
+
245  case LayerType::Convolution2d:
+
246  {
+
247  if (infos.size() != 4)
+
248  {
+
249  throw InvalidArgumentException("Invalid number of TransposeConvolution2d TensorInfos. "
+
250  "TensorInfos should be of format: {input, output, weights, biases}.");
+
251  }
+
252 
+
253  auto desc = *(PolymorphicDowncast<const Convolution2dDescriptor*>(&descriptor));
+
254  if (infos[3] == TensorInfo())
+
255  {
+
256  return support.IsConvolution2dSupported(infos[0],
+
257  infos[1],
+
258  desc,
+
259  infos[2],
+
260  EmptyOptional(),
+
261  reasonIfUnsupported);
+
262  }
+
263  else
+
264  {
+
265  return support.IsConvolution2dSupported(infos[0],
+
266  infos[1],
+
267  desc,
+
268  infos[2],
+
269  infos[3],
+
270  reasonIfUnsupported);
+
271  }
+
272  }
+
273  case LayerType::Convolution3d:
+
274  {
+
275  if (infos.size() != 4)
+
276  {
+
277  throw InvalidArgumentException("Invalid number of Convolution3d TensorInfos. "
+
278  "TensorInfos should be of format: {input, output, weights, biases}.");
+
279  }
+
280 
+
281  auto desc = *(PolymorphicDowncast<const Convolution3dDescriptor*>(&descriptor));
+
282  if (infos[3] == TensorInfo())
+
283  {
+
284  return support.IsConvolution3dSupported(infos[0],
+
285  infos[1],
+
286  desc,
+
287  infos[2],
+
288  EmptyOptional(),
+
289  reasonIfUnsupported);
+
290  }
+
291  else
+
292  {
+
293  return support.IsConvolution3dSupported(infos[0],
+
294  infos[1],
+
295  desc,
+
296  infos[2],
+
297  infos[3],
+
298  reasonIfUnsupported);
+
299  }
+
300  }
+
301  case LayerType::DepthToSpace:
+
302  return support.IsDepthToSpaceSupported(infos[0],
+
303  infos[1],
+
304  *(PolymorphicDowncast<const DepthToSpaceDescriptor*>(&descriptor)),
+
305  reasonIfUnsupported);
+
306  case LayerType::DepthwiseConvolution2d:
+
307  {
+
308  if (infos.size() != 4)
+
309  {
+
310  throw InvalidArgumentException("Invalid number of DepthwiseConvolution2d TensorInfos. "
+
311  "TensorInfos should be of format: {input, output, weights, biases}.");
+
312  }
+
313 
+
314  auto desc = *(PolymorphicDowncast<const DepthwiseConvolution2dDescriptor*>(&descriptor));
+
315  if (infos[3] == TensorInfo())
+
316  {
+
317  return support.IsDepthwiseConvolutionSupported(infos[0],
+
318  infos[1],
+
319  desc,
+
320  infos[2],
+
321  EmptyOptional(),
+
322  reasonIfUnsupported);
+
323  }
+
324  else
+
325  {
+
326  return support.IsDepthwiseConvolutionSupported(infos[0],
+
327  infos[1],
+
328  desc,
+
329  infos[2],
+
330  infos[3],
+
331  reasonIfUnsupported);
+
332  }
+
333  }
+
334  case LayerType::Dequantize:
+
335  return support.IsDequantizeSupported(infos[0], infos[1], reasonIfUnsupported);
+
336  case LayerType::DetectionPostProcess:
+
337  {
+
338  auto desc = *(PolymorphicDowncast<const DetectionPostProcessDescriptor*>(&descriptor));
+
339  return support.IsDetectionPostProcessSupported(infos[0],
+
340  infos[1],
+
341  infos[2],
+
342  infos[3],
+
343  infos[4],
+
344  infos[5],
+
345  infos[6],
+
346  desc,
+
347  reasonIfUnsupported);
+
348  }
+
349  case LayerType::Division:
+
350  return support.IsDivisionSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
+
351  case LayerType::ElementwiseBinary:
+
352  {
+
353  auto desc = *(PolymorphicDowncast<const ElementwiseBinaryDescriptor *>(&descriptor));
+
354 
+
355  switch (desc.m_Operation)
+
356  {
+
357  case BinaryOperation::Add:
+
358  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonAdditionWorkloadValidate,
+
359  reasonIfUnsupported,
+
360  infos[0],
+
361  infos[1],
+
362  infos[2],
+
363  nullptr);
+
364  case BinaryOperation::Div:
+
365  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonDivisionWorkloadValidate,
+
366  reasonIfUnsupported,
+
367  infos[0],
+
368  infos[1],
+
369  infos[2],
+
370  nullptr);
+
371  case BinaryOperation::Maximum:
+
372  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonMaximumWorkloadValidate,
+
373  reasonIfUnsupported,
+
374  infos[0],
+
375  infos[1],
+
376  infos[2]);
+
377  case BinaryOperation::Minimum:
+
378  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonMinimumWorkloadValidate,
+
379  reasonIfUnsupported,
+
380  infos[0],
+
381  infos[1],
+
382  infos[2]);
+
383  case BinaryOperation::Mul:
+
384  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonMultiplicationWorkloadValidate,
+
385  reasonIfUnsupported,
+
386  infos[0],
+
387  infos[1],
+
388  infos[2],
+
389  nullptr);
+
390  case BinaryOperation::Sub:
+
391  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonSubtractionWorkloadValidate,
+
392  reasonIfUnsupported,
+
393  infos[0],
+
394  infos[1],
+
395  infos[2],
+
396  nullptr);
+
397  default:
+
398  return false;
+
399  }
+
400  }
+
401  case LayerType::ElementwiseUnary:
+
402  return support.IsElementwiseUnarySupported(infos[0],
+
403  infos[1],
+
404  *(PolymorphicDowncast<const
+
405  ElementwiseUnaryDescriptor*>(&descriptor)),
+
406  reasonIfUnsupported);
+
407  case LayerType::Fill:
+
408  return support.IsFillSupported(infos[0],
+
409  infos[1],
+
410  *(PolymorphicDowncast<const FillDescriptor*>(&descriptor)),
+
411  reasonIfUnsupported);
+
412  case LayerType::Floor:
+
413  return support.IsFloorSupported(infos[0], infos[1], reasonIfUnsupported);
+
414  case LayerType::FullyConnected:
+
415  return support.IsFullyConnectedSupported(infos[0],
+
416  infos[1],
+
417  infos[2],
+
418  infos[3],
+
419  *(PolymorphicDowncast<const
+
420  FullyConnectedDescriptor*>(&descriptor)),
+
421  reasonIfUnsupported);
+
422  case LayerType::Gather:
+
423  return support.IsGatherSupported(infos[0],
+
424  infos[1],
+
425  infos[2],
+
426  *(PolymorphicDowncast<const GatherDescriptor*>(&descriptor)),
+
427  reasonIfUnsupported);
+
428  case LayerType::GatherNd:
+
429  return support.IsGatherNdSupported(infos[0],
+
430  infos[1],
+
431  infos[2],
+
432  reasonIfUnsupported);
+
433  case LayerType::Input:
+
434  return support.IsInputSupported(infos[0], reasonIfUnsupported);
+
435  case LayerType::InstanceNormalization:
+
436  return support.IsInstanceNormalizationSupported(infos[0],
+
437  infos[1],
+
438  *(PolymorphicDowncast<const
+
439  InstanceNormalizationDescriptor*>(&descriptor)),
+
440  reasonIfUnsupported);
+
441  case LayerType::L2Normalization:
+
442  return support.IsL2NormalizationSupported(infos[0],
+
443  infos[1],
+
444  *(PolymorphicDowncast<const
+
445  L2NormalizationDescriptor*>(&descriptor)),
+
446  reasonIfUnsupported);
+
447  case LayerType::LogicalBinary:
+
448  return support.IsLogicalBinarySupported(infos[0],
+
449  infos[1],
+
450  infos[2],
+
451  *(PolymorphicDowncast<const
+
452  LogicalBinaryDescriptor*>(&descriptor)),
+
453  reasonIfUnsupported);
+
454  case LayerType::LogSoftmax:
+
455  return support.IsLogSoftmaxSupported(infos[0],
+
456  infos[1],
+
457  *(PolymorphicDowncast<const LogSoftmaxDescriptor*>(&descriptor)),
+
458  reasonIfUnsupported);
+
459  case LayerType::Lstm:
+
460  return support.IsLstmSupported(infos[0],
+
461  infos[1],
+
462  infos[2],
+
463  infos[3],
+
464  infos[4],
+
465  infos[5],
+
466  infos[6],
+
467  *(PolymorphicDowncast<const LstmDescriptor*>(&descriptor)),
+
468  lstmParamsInfo.value(),
+
469  reasonIfUnsupported);
+
470  case LayerType::Map:
+
471  return true;
+
472  case LayerType::Maximum:
+
473  return support.IsMaximumSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
+
474  case LayerType::Mean:
+
475  return support.IsMeanSupported(infos[0],
+
476  infos[1],
+
477  *(PolymorphicDowncast<const MeanDescriptor*>(&descriptor)),
+
478  reasonIfUnsupported);
+
479  case LayerType::MemCopy:
+
480  return support.IsMemCopySupported(infos[0], infos[1], reasonIfUnsupported);
+
481  case LayerType::MemImport:
+
482  return support.IsMemImportSupported(infos[0], infos[1], reasonIfUnsupported);
+
483  case LayerType::Merge:
+
484  return support.IsMergeSupported(infos[0],
+
485  infos[1],
+
486  infos[2],
+
487  reasonIfUnsupported);
+
488  case LayerType::Minimum:
+
489  return support.IsMinimumSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
+
490  case LayerType::Multiplication:
+
491  return support.IsMultiplicationSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
+
492  case LayerType::Normalization:
+
493  return support.IsNormalizationSupported(infos[0],
+
494  infos[1],
+
495  *(PolymorphicDowncast<const
+
496  NormalizationDescriptor*>(&descriptor)),
+
497  reasonIfUnsupported);
+
498  case LayerType::Output:
+
499  return support.IsOutputSupported(infos[0], reasonIfUnsupported);
+
500  case LayerType::Pad:
+
501  return support.IsPadSupported(infos[0],
+
502  infos[1],
+
503  *(PolymorphicDowncast<const PadDescriptor*>(&descriptor)),
+
504  reasonIfUnsupported);
+
505  case LayerType::Permute:
+
506  return support.IsPermuteSupported(infos[0],
+
507  infos[1],
+
508  *(PolymorphicDowncast<const PermuteDescriptor*>(&descriptor)),
+
509  reasonIfUnsupported);
+
510  case LayerType::Pooling2d:
+
511  return support.IsPooling2dSupported(infos[0],
+
512  infos[1],
+
513  *(PolymorphicDowncast<const Pooling2dDescriptor*>(&descriptor)),
+
514  reasonIfUnsupported);
+
515  case LayerType::Pooling3d:
+
516  return support.IsPooling3dSupported(infos[0],
+
517  infos[1],
+
518  *(PolymorphicDowncast<const Pooling3dDescriptor*>(&descriptor)),
+
519  reasonIfUnsupported);
+
520  case LayerType::Prelu:
+
521  return support.IsPreluSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
+
522  case LayerType::QLstm:
+
523  return support.IsQLstmSupported(infos[0],
+
524  infos[1],
+
525  infos[2],
+
526  infos[3],
+
527  infos[4],
+
528  infos[5],
+
529  *(PolymorphicDowncast<const QLstmDescriptor*>(&descriptor)),
+
530  lstmParamsInfo.value(),
+
531  reasonIfUnsupported);
+
532  case LayerType::Quantize:
+
533  return support.IsQuantizeSupported(infos[0], infos[1], reasonIfUnsupported);
+
534  case LayerType::QuantizedLstm:
+
535  return support.IsQuantizedLstmSupported(infos[0],
+
536  infos[1],
+
537  infos[2],
+
538  infos[3],
+
539  infos[4],
+
540  quantizedLstmParamsInfo.value(),
+
541  reasonIfUnsupported);
+
542  case LayerType::Rank:
+
543  return true;
+
544  case LayerType::Reshape:
+
545  return support.IsReshapeSupported(infos[0],
+
546  infos[1],
+
547  *(PolymorphicDowncast<const ReshapeDescriptor*>(&descriptor)),
+
548  reasonIfUnsupported);
+
549  case LayerType::Resize:
+
550  return support.IsResizeSupported(infos[0],
+
551  infos[1],
+
552  *(PolymorphicDowncast<const ResizeDescriptor*>(&descriptor)),
+
553  reasonIfUnsupported);
+
554  case LayerType::Reduce:
+
555  return support.IsReduceSupported(infos[0],
+
556  infos[1],
+
557  *(PolymorphicDowncast<const ReduceDescriptor*>(&descriptor)),
+
558  reasonIfUnsupported);
+
559  case LayerType::Shape:
+
560  return support.IsShapeSupported(infos[0],
+
561  infos[1],
+
562  reasonIfUnsupported);
+
563  case LayerType::Slice:
+
564  return support.IsSliceSupported(infos[0],
+
565  infos[1],
+
566  *(PolymorphicDowncast<const SliceDescriptor*>(&descriptor)),
+
567  reasonIfUnsupported);
+
568  case LayerType::Softmax:
+
569  return support.IsSoftmaxSupported(infos[0],
+
570  infos[1],
+
571  *(PolymorphicDowncast<const SoftmaxDescriptor*>(&descriptor)),
+
572  reasonIfUnsupported);
+
573  case LayerType::SpaceToBatchNd:
+
574  return support.IsSpaceToBatchNdSupported(infos[0],
+
575  infos[1],
+
576  *(PolymorphicDowncast<const
+
577  SpaceToBatchNdDescriptor*>(&descriptor)),
+
578  reasonIfUnsupported);
+
579  case LayerType::SpaceToDepth:
+
580  return support.IsSpaceToDepthSupported(infos[0],
+
581  infos[1],
+
582  *(PolymorphicDowncast<const SpaceToDepthDescriptor*>(&descriptor)),
+
583  reasonIfUnsupported);
+
584  case LayerType::Splitter:
+
585  {
+
586  std::vector<TensorInfo> outputInfos;
+
587  for (uint32_t i = 1; i < infos.size(); i++)
+
588  {
+
589  outputInfos.push_back(infos[i]);
+
590  }
+
591  return support.IsSplitterSupported(infos[0],
+
592  {outputInfos.begin(), outputInfos.end()},
+
593  *(PolymorphicDowncast<const ViewsDescriptor*>(&descriptor)),
+
594  reasonIfUnsupported);
+
595  }
+
596  case LayerType::Stack:
+
597  {
+
598  std::vector<const TensorInfo*> inputInfos;
+
599  for (uint32_t i = 0; i < infos.size() - 1; i++)
+
600  {
+
601  inputInfos.push_back(&infos[i]);
+
602  }
+
603  return support.IsStackSupported(inputInfos,
+
604  infos[infos.size() - 1],
+
605  *(PolymorphicDowncast<const StackDescriptor*>(&descriptor)),
+
606  reasonIfUnsupported);
+
607  }
+
608  case LayerType::StridedSlice:
+
609  return support.IsStridedSliceSupported(infos[0],
+
610  infos[1],
+
611  *(PolymorphicDowncast<const StridedSliceDescriptor*>(&descriptor)),
+
612  reasonIfUnsupported);
+
613  case LayerType::Subtraction:
+
614  return support.IsSubtractionSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
+
615  case LayerType::Transpose:
+
616  return support.IsTransposeSupported(infos[0],
+
617  infos[1],
+
618  *(PolymorphicDowncast<const TransposeDescriptor*>(&descriptor)),
+
619  reasonIfUnsupported);
+
620  case LayerType::TransposeConvolution2d:
+
621  {
+
622  if (infos.size() != 4)
+
623  {
+
624  throw InvalidArgumentException("Invalid number of TransposeConvolution2d TensorInfos. "
+
625  "TensorInfos should be of format: {input, output, weights, biases}.");
+
626  }
+
627 
+
628  auto desc = *(PolymorphicDowncast<const TransposeConvolution2dDescriptor*>(&descriptor));
+
629  if (infos[3] == TensorInfo())
+
630  {
+
631  return support.IsTransposeConvolution2dSupported(infos[0],
+
632  infos[1],
+
633  desc,
+
634  infos[2],
+
635  EmptyOptional(),
+
636  reasonIfUnsupported);
+
637  }
+
638  else
+
639  {
+
640  return support.IsTransposeConvolution2dSupported(infos[0],
+
641  infos[1],
+
642  desc,
+
643  infos[2],
+
644  infos[3],
+
645  reasonIfUnsupported);
+
646  }
+
647  }
+
648  case LayerType::UnidirectionalSequenceLstm:
+
649  {
+
650  auto desc = *(PolymorphicDowncast<const UnidirectionalSequenceLstmDescriptor*>(&descriptor));
+
651  return support.IsUnidirectionalSequenceLstmSupported(infos[0],
+
652  infos[1],
+
653  infos[2],
+
654  infos[3],
+
655  infos[4],
+
656  infos[5],
+
657  desc,
+
658  lstmParamsInfo.value(),
+
659  reasonIfUnsupported);
+
660  }
+
661  case LayerType::Unmap:
+
662  return true;
+
663  default:
+
664  // layers not supported in neon by default:
+
665  // debug, fakequantization, precompiled,
+
666  // standin, switch
+
667  return false;
+
668  }
+
669 }
+
670 
+
671 bool NeonLayerSupport::IsLayerSupported(const LayerType& type,
+
672  const std::vector<TensorInfo>& infos,
+
673  const BaseDescriptor& descriptor,
+
674  const Optional<LstmInputParamsInfo>& lstmParamsInfo,
+
675  const Optional<QuantizedLstmInputParamsInfo>& quantizedLstmParamsInfo,
+
676  Optional<std::string&> reasonIfUnsupported) const
+
677 {
+
678  bool isSupported = IsLayerTypeSupported(type,
+
679  infos,
+
680  descriptor,
+
681  lstmParamsInfo,
+
682  quantizedLstmParamsInfo,
+
683  reasonIfUnsupported,
+
684  *this);
+
685 
+
686  // For android-nn-driver and support library, to run FP16 operations on CpuAcc we need at least v8.2
+
687  // architecture. If the available architecture is older than v8.2, we can check if the operator is
+
688  // supported by changing operator inputs & outputs to be FP32.
+
689  // This does not change the operator datatype in the above parsers to be FP32. We are simply reporting
+
690  // to the parsers if the operator can supported in ArmNN. We will then re-enter ArmNN (Network.cpp)
+
691  // where we will recheck IsLayerSupported() on the FP16 datatype, update the operator to be FP32,
+
692  // and, insert convert layers around the FP32 operator.
+
693  if (reasonIfUnsupported.has_value())
+
694  {
+
695  std::string checkStr = "This CPU architecture does not support F16 data type, you need v8.2 or above";
+
696  if (!isSupported
+
697  && reasonIfUnsupported.value().find(checkStr) != std::string::npos)
+
698  {
+
699  std::vector<TensorInfo> newInfos;
+
700  for (auto info: infos)
+
701  {
+
702  newInfos.emplace_back(OverrideDataType(info, DataType::Float32));
+
703  }
+
704 
+
705  std::string tmpString;
+
706  return IsLayerTypeSupported(type,
+
707  newInfos,
+
708  descriptor,
+
709  lstmParamsInfo,
+
710  quantizedLstmParamsInfo,
+
711  tmpString,
+
712  *this);
+
713  }
+
714  }
+
715 
+
716  return isSupported;
+
717 }
+
718 
+
719 bool NeonLayerSupport::IsActivationSupported(const TensorInfo& input,
+
720  const TensorInfo& output,
+
721  const ActivationDescriptor& descriptor,
+
722  Optional<std::string&> reasonIfUnsupported) const
+
723 {
+
724  IgnoreUnused(descriptor);
+
725  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonActivationWorkloadValidate,
+
726  reasonIfUnsupported,
+
727  input,
+
728  output,
+
729  descriptor);
+
730 }
+
731 
+
732 bool NeonLayerSupport::IsAdditionSupported(const TensorInfo& input0,
+
733  const TensorInfo& input1,
+
734  const TensorInfo& output,
+
735  Optional<std::string&> reasonIfUnsupported) const
+
736 {
+
737  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonAdditionWorkloadValidate,
+
738  reasonIfUnsupported,
+
739  input0,
+
740  input1,
+
741  output,
+
742  nullptr);
+
743 }
+
744 
+
745 bool NeonLayerSupport::IsArgMinMaxSupported(const TensorInfo& input,
+
746  const TensorInfo& output,
+
747  const ArgMinMaxDescriptor& descriptor,
+
748  Optional<std::string&> reasonIfUnsupported) const
+
749 {
+
750  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonArgMinMaxWorkloadValidate,
+
751  reasonIfUnsupported,
+
752  input,
+
753  output,
+
754  descriptor);
+
755 }
+
756 
+
757 bool NeonLayerSupport::IsBatchMatMulSupported(const TensorInfo& inputX,
+
758  const TensorInfo& inputY,
+
759  const TensorInfo& output,
+
760  const BatchMatMulDescriptor& descriptor,
+
761  Optional<std::string&> reasonIfUnsupported) const
+
762 {
+
763  bool isFastMathEnabled = false;
+
764 #if defined(ARMCOMPUTENEON_ENABLED)
+
765  if (m_ModelContextPtr)
+
766  {
+
767  if (m_ModelContextPtr.get() != nullptr)
+
768  {
+
769  auto modelOptions = dynamic_cast<NeonBackendModelContext*>(m_ModelContextPtr.get());
+
770  if (modelOptions)
+
771  {
+
772  isFastMathEnabled = modelOptions->IsFastMathEnabled();
+
773  }
+
774  }
+
775  }
+
776 #endif
+
777  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonBatchMatMulValidate,
+
778  reasonIfUnsupported,
+
779  inputX,
+
780  inputY,
+
781  output,
+
782  descriptor,
+
783  isFastMathEnabled,
+
784  nullptr);
+
785 }
+
786 
+
787 bool NeonLayerSupport::IsBatchNormalizationSupported(const TensorInfo& input,
+
788  const TensorInfo& output,
+
789  const TensorInfo& mean,
+
790  const TensorInfo& var,
+
791  const TensorInfo& beta,
+
792  const TensorInfo& gamma,
+
793  const BatchNormalizationDescriptor& descriptor,
+
794  Optional<std::string&> reasonIfUnsupported) const
+
795 {
+
796  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonBatchNormalizationValidate,
+
797  reasonIfUnsupported,
+
798  input,
+
799  output,
+
800  mean,
+
801  var,
+
802  beta,
+
803  gamma,
+
804  descriptor,
+
805  nullptr);
+
806 }
+
807 
+
808 bool NeonLayerSupport::IsBatchToSpaceNdSupported(const TensorInfo& input,
+
809  const TensorInfo& output,
+
810  const BatchToSpaceNdDescriptor& descriptor,
+
811  Optional<std::string&> reasonIfUnsupported) const
+
812 {
+
813  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonBatchToSpaceNdWorkloadValidate,
+
814  reasonIfUnsupported,
+
815  input,
+
816  output,
+
817  descriptor);
+
818 }
+
819 
+
820 bool NeonLayerSupport::IsCastSupported(const TensorInfo& input,
+
821  const TensorInfo& output,
+
822  Optional<std::string&> reasonIfUnsupported) const
+
823 {
+
824  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonCastValidate,
+
825  reasonIfUnsupported,
+
826  input,
+
827  output);
+
828 }
+
829 
+
830 bool NeonLayerSupport::IsChannelShuffleSupported(const TensorInfo& input,
+
831  const TensorInfo& output,
+
832  const ChannelShuffleDescriptor& descriptor,
+
833  Optional<std::string&> reasonIfUnsupported) const
+
834 {
+
835  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonChannelShuffleValidate,
+
836  reasonIfUnsupported,
+
837  input,
+
838  output,
+
839  descriptor);
+
840 }
+
841 
+
842 bool NeonLayerSupport::IsComparisonSupported(const TensorInfo& input0,
+
843  const TensorInfo& input1,
+
844  const TensorInfo& output,
+
845  const ComparisonDescriptor& descriptor,
+
846  Optional<std::string&> reasonIfUnsupported) const
+
847 {
+
848 
+
849  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonComparisonWorkloadValidate,
+
850  reasonIfUnsupported,
+
851  input0,
+
852  input1,
+
853  output,
+
854  descriptor);
+
855 }
+
856 
+
857 bool NeonLayerSupport::IsConcatSupported(const std::vector<const TensorInfo*> inputs,
+
858  const TensorInfo& output,
+
859  const OriginsDescriptor& descriptor,
+
860  Optional<std::string&> reasonIfUnsupported) const
+
861 {
+
862  if (descriptor.GetNumDimensions() <= descriptor.GetConcatAxis())
+
863  {
+
864  SetValueChecked(reasonIfUnsupported, "Neon Concat: Concat axis > Number of dimensions.");
+
865  return false;
+
866  }
+
867 
+
868  unsigned int concatInnerAxis = (descriptor.GetNumDimensions() - descriptor.GetConcatAxis()) - 1;
+
869  if(concatInnerAxis < 3) // Width, height, or channels
+
870  {
+
871  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonConcatWorkloadValidate,
+
872  reasonIfUnsupported,
+
873  inputs,
+
874  output,
+
875  descriptor);
+
876  }
+
877  else if (concatInnerAxis == 3)
+
878  {
+
879  for (auto& input : inputs)
+
880  {
+
881  if (input && !output.IsTypeSpaceMatch(*input)) // Cannot use sub-tensors if the types are not same space
+
882  {
+
883  SetValueChecked(reasonIfUnsupported, "Neon Concat: Types and quantization parameters must match.");
+
884  return false;
+
885  }
+
886  }
+
887  return true; // Sub-tensors support concat along batch
+
888  }
+
889  else // > 4 dimensions not supported.
+
890  {
+
891  SetValueChecked(reasonIfUnsupported, "Neon Concat: Maximum of 4 dimensions supported.");
+
892  return false;
+
893  }
+
894 }
+
895 
+
896 bool NeonLayerSupport::IsConstantSupported(const TensorInfo& output,
+
897  Optional<std::string&> reasonIfUnsupported) const
+
898 {
+
899  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonConstantWorkloadValidate,
+
900  reasonIfUnsupported,
+
901  output);
+
902 }
+
903 
+
904 bool NeonLayerSupport::IsConvertFp16ToFp32Supported(const TensorInfo& input,
+
905  const TensorInfo& output,
+
906  Optional<std::string&> reasonIfUnsupported) const
+
907 {
+
908  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonConvertFp16ToFp32WorkloadValidate,
+
909  reasonIfUnsupported,
+
910  input,
+
911  output);
+
912 }
+
913 
+
914 bool NeonLayerSupport::IsConvertFp32ToFp16Supported(const TensorInfo& input,
+
915  const TensorInfo& output,
+
916  Optional<std::string&> reasonIfUnsupported) const
+
917 {
+
918  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonConvertFp32ToFp16WorkloadValidate,
+
919  reasonIfUnsupported,
+
920  input,
+
921  output);
+
922 }
+
923 
+
924 bool NeonLayerSupport::IsConvolution2dSupported(const TensorInfo& input,
+
925  const TensorInfo& output,
+
926  const Convolution2dDescriptor& descriptor,
+
927  const TensorInfo& weights,
+
928  const Optional<TensorInfo>& biases,
+
929  Optional<std::string&> reasonIfUnsupported) const
+
930 {
+
931  bool isFastMathEnabled = false;
+
932 #if defined(ARMCOMPUTENEON_ENABLED)
+
933  if (m_ModelContextPtr)
+
934  {
+
935  if (m_ModelContextPtr.get() != nullptr)
+
936  {
+
937  auto modelOptions = dynamic_cast<NeonBackendModelContext*>(m_ModelContextPtr.get());
+
938  if (modelOptions)
+
939  {
+
940  isFastMathEnabled = modelOptions->IsFastMathEnabled();
+
941  }
+
942  }
+
943  }
+
944 #endif
+
945 
+
946  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonConvolution2dWorkloadValidate,
+
947  reasonIfUnsupported,
+
948  input,
+
949  output,
+
950  descriptor,
+
951  weights,
+
952  biases,
+
953  isFastMathEnabled,
+
954  nullptr);
+
955 }
+
956 
+
957 bool NeonLayerSupport::IsConvolution3dSupported(const TensorInfo& input,
+
958  const TensorInfo& output,
+
959  const Convolution3dDescriptor& descriptor,
+
960  const TensorInfo& weights,
+
961  const Optional<TensorInfo>& biases,
+
962  Optional<std::string&> reasonIfUnsupported) const
+
963 {
+
964  bool isFastMathEnabled = false;
+
965 #if defined(ARMCOMPUTENEON_ENABLED)
+
966  if (m_ModelContextPtr)
+
967  {
+
968  if (m_ModelContextPtr.get() != nullptr)
+
969  {
+
970  auto modelOptions = dynamic_cast<NeonBackendModelContext*>(m_ModelContextPtr.get());
+
971  if (modelOptions)
+
972  {
+
973  isFastMathEnabled = modelOptions->IsFastMathEnabled();
+
974  }
+
975  }
+
976  }
+
977 #endif
+
978 
+
979  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonConvolution3dWorkloadValidate,
+
980  reasonIfUnsupported,
+
981  input,
+
982  output,
+
983  descriptor,
+
984  weights,
+
985  biases,
+
986  isFastMathEnabled,
+
987  nullptr);
+
988 }
+
989 
+
990 bool NeonLayerSupport::IsDepthToSpaceSupported(const TensorInfo& input,
+
991  const TensorInfo& output,
+
992  const DepthToSpaceDescriptor& descriptor,
+
993  Optional<std::string&> reasonIfUnsupported) const
+
994 {
+
995  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonDepthToSpaceWorkloadValidate,
+
996  reasonIfUnsupported,
+
997  input,
+
998  output,
+
999  descriptor);
+
1000 }
+
1001 
+
1002 bool NeonLayerSupport::IsDepthwiseConvolutionSupported(const TensorInfo& input,
+
1003  const TensorInfo& output,
+
1004  const DepthwiseConvolution2dDescriptor& descriptor,
+
1005  const TensorInfo& weights,
+
1006  const Optional<TensorInfo>& biases,
+
1007  Optional<std::string&> reasonIfUnsupported) const
+
1008 {
+
1009  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonDepthwiseConvolutionWorkloadValidate,
+
1010  reasonIfUnsupported,
+
1011  input,
+
1012  output,
+
1013  descriptor,
+
1014  weights,
+
1015  biases,
+
1016  nullptr);
+
1017 }
+
1018 
+
1019 bool NeonLayerSupport::IsDequantizeSupported(const TensorInfo& input,
+
1020  const TensorInfo& output,
+
1021  Optional<std::string&> reasonIfUnsupported) const
+
1022 {
+
1023  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonDequantizeWorkloadValidate,
+
1024  reasonIfUnsupported,
+
1025  input,
+
1026  output);
+
1027 }
+
1028 
+
1029 bool NeonLayerSupport::IsDilatedDepthwiseConvolutionSupported(const TensorInfo& input,
+
1030  const TensorInfo& output,
+
1031  const DepthwiseConvolution2dDescriptor& descriptor,
+
1032  const TensorInfo& weights,
+
1033  const Optional<TensorInfo>& biases,
+
1034  Optional<std::string&> reasonIfUnsupported) const
+
1035 {
+
1036  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonDepthwiseConvolutionWorkloadValidate,
+
1037  reasonIfUnsupported,
+
1038  input,
+
1039  output,
+
1040  descriptor,
+
1041  weights,
+
1042  biases,
+
1043  nullptr);
+
1044 }
+
1045 
+
1046 bool NeonLayerSupport::IsElementwiseUnarySupported(const TensorInfo& input,
+
1047  const TensorInfo& output,
+
1048  const ElementwiseUnaryDescriptor& descriptor,
+
1049  Optional<std::string&> reasonIfUnsupported) const
+
1050 {
+
1051  switch(descriptor.m_Operation)
+
1052  {
+
1053  case UnaryOperation::Abs:
+
1054  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonAbsWorkloadValidate,
+
1055  reasonIfUnsupported,
+
1056  input,
+
1057  output);
+
1058  case UnaryOperation::Exp:
+
1059  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonExpWorkloadValidate,
+
1060  reasonIfUnsupported,
+
1061  input,
+
1062  output);
+
1063  case UnaryOperation::LogicalNot:
+
1064  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonLogicalNotWorkloadValidate,
+
1065  reasonIfUnsupported,
+
1066  input,
+
1067  output);
+
1068  case UnaryOperation::Log:
+
1069  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonLogWorkloadValidate,
+
1070  reasonIfUnsupported,
+
1071  input,
+
1072  output);
+
1073  case UnaryOperation::Neg:
+
1074  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonNegWorkloadValidate,
+
1075  reasonIfUnsupported,
+
1076  input,
+
1077  output);
+
1078  case UnaryOperation::Rsqrt:
+
1079  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonRsqrtWorkloadValidate,
+
1080  reasonIfUnsupported,
+
1081  input,
+
1082  output);
+
1083  case UnaryOperation::Sin:
+
1084  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonSinWorkloadValidate,
+
1085  reasonIfUnsupported,
+
1086  input,
+
1087  output);
+
1088  case UnaryOperation::Sqrt:
+
1089  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonSqrtWorkloadValidate,
+
1090  reasonIfUnsupported,
+
1091  input,
+
1092  output);
+
1093  default:
+
1094  return false;
+
1095  }
+
1096 }
+
1097 
+
1098 bool NeonLayerSupport::IsFillSupported(const TensorInfo& input,
+
1099  const TensorInfo& output,
+
1100  const FillDescriptor& descriptor,
+
1101  Optional<std::string&> reasonIfUnsupported) const
+
1102 {
+
1103  armnn::IgnoreUnused(input);
+
1104  armnn::IgnoreUnused(output);
+
1105  armnn::IgnoreUnused(descriptor);
+
1106 
+
1107  return IsNeonBackendSupported(reasonIfUnsupported);
+
1108 }
+
1109 
+
1110 bool NeonLayerSupport::IsFloorSupported(const TensorInfo& input,
+
1111  const TensorInfo& output,
+
1112  Optional<std::string&> reasonIfUnsupported) const
+
1113 {
+
1114  armnn::IgnoreUnused(output);
+
1115  return IsNeonBackendSupported(reasonIfUnsupported) &&
+
1116  IsSupportedForDataTypeGeneric(reasonIfUnsupported,
+
1117  input.GetDataType(),
+
1118  &FalseFuncF16<>,
+
1119  &TrueFunc<>,
+
1120  &FalseFuncU8<>,
+
1121  &FalseFuncI32<>,
+
1122  &FalseFuncU8<>);
+
1123 }
+
1124 
+
1125 bool NeonLayerSupport::IsFullyConnectedSupported(const TensorInfo& input,
+
1126  const TensorInfo& output,
+
1127  const TensorInfo& weights,
+
1128  const TensorInfo& biases,
+
1129  const FullyConnectedDescriptor& descriptor,
+
1130  Optional<std::string&> reasonIfUnsupported) const
+
1131 {
+
1132  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonFullyConnectedWorkloadValidate,
+
1133  reasonIfUnsupported,
+
1134  input,
+
1135  output,
+
1136  weights,
+
1137  biases,
+
1138  descriptor,
+
1139  nullptr);
+
1140 }
+
1141 
+
1142 bool NeonLayerSupport::IsGatherSupported(const TensorInfo& input0,
+
1143  const TensorInfo& input1,
+
1144  const TensorInfo& output,
+
1145  const GatherDescriptor& descriptor,
+
1146  Optional<std::string&> reasonIfUnsupported) const
+
1147 {
+
1148  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonGatherWorkloadValidate,
+
1149  reasonIfUnsupported,
+
1150  input0,
+
1151  input1,
+
1152  output,
+
1153  descriptor);
+
1154 }
+
1155 
+
1156 bool NeonLayerSupport::IsGatherNdSupported(const TensorInfo& input0,
+
1157  const TensorInfo& input1,
+
1158  const TensorInfo& output,
+
1159  Optional<std::string&> reasonIfUnsupported) const
+
1160 {
+
1161  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonGatherNdWorkloadValidate,
+
1162  reasonIfUnsupported,
+
1163  input0,
+
1164  input1,
+
1165  output);
+
1166 }
+
1167 
+
1168 bool NeonLayerSupport::IsInputSupported(const TensorInfo& input,
+
1169  Optional<std::string&> reasonIfUnsupported) const
+
1170 {
+
1171  return IsNeonBackendSupported(reasonIfUnsupported, input);
+
1172 }
+
1173 
+
1174 bool NeonLayerSupport::IsInstanceNormalizationSupported(const TensorInfo& input,
+
1175  const TensorInfo& output,
+
1176  const InstanceNormalizationDescriptor& descriptor,
+
1177  Optional<std::string&> reasonIfUnsupported) const
+
1178 {
+
1179  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonInstanceNormalizationWorkloadValidate,
+
1180  reasonIfUnsupported,
+
1181  input,
+
1182  output,
+
1183  descriptor);
+
1184 }
+
1185 
+
1186 bool NeonLayerSupport::IsL2NormalizationSupported(const TensorInfo& input,
+
1187  const TensorInfo& output,
+
1188  const L2NormalizationDescriptor& descriptor,
+
1189  Optional<std::string&> reasonIfUnsupported) const
+
1190 {
+
1191  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonL2NormalizationWorkloadValidate, reasonIfUnsupported, input, output, descriptor);
+
1192 }
+
1193 
+
1194 bool NeonLayerSupport::IsLogicalBinarySupported(const TensorInfo& input0,
+
1195  const TensorInfo& input1,
+
1196  const TensorInfo& output,
+
1197  const LogicalBinaryDescriptor& descriptor,
+
1198  Optional<std::string&> reasonIfUnsupported) const
+
1199 {
+
1200  switch(descriptor.m_Operation)
+
1201  {
+
1202  case LogicalBinaryOperation::LogicalAnd:
+
1203  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonLogicalAndWorkloadValidate,
+
1204  reasonIfUnsupported,
+
1205  input0,
+
1206  input1,
+
1207  output);
+
1208  case LogicalBinaryOperation::LogicalOr:
+
1209  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonLogicalOrWorkloadValidate,
+
1210  reasonIfUnsupported,
+
1211  input0,
+
1212  input1,
+
1213  output);
+
1214  default:
+
1215  return false;
+
1216  }
+
1217 }
+
1218 
+
1219 bool NeonLayerSupport::IsLogSoftmaxSupported(const TensorInfo& input,
+
1220  const TensorInfo& output,
+
1221  const LogSoftmaxDescriptor& descriptor,
+
1222  Optional<std::string&> reasonIfUnsupported) const
+
1223 {
+
1224  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonLogSoftmaxWorkloadValidate, reasonIfUnsupported, input, output, descriptor);
+
1225 }
+
1226 
+
1227 bool NeonLayerSupport::IsLstmSupported(const TensorInfo& input,
+
1228  const TensorInfo& outputStateIn,
+
1229  const TensorInfo& cellStateIn,
+
1230  const TensorInfo& scratchBuffer,
+
1231  const TensorInfo& outputStateOut,
+
1232  const TensorInfo& cellStateOut,
+
1233  const TensorInfo& output,
+
1234  const LstmDescriptor& descriptor,
+
1235  const LstmInputParamsInfo& paramsInfo,
+
1236  Optional<std::string&> reasonIfUnsupported) const
+
1237 {
+
1238  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonLstmFloatWorkloadValidate,
+
1239  reasonIfUnsupported,
+
1240  input,
+
1241  outputStateIn,
+
1242  cellStateIn,
+
1243  scratchBuffer,
+
1244  outputStateOut,
+
1245  cellStateOut,
+
1246  output,
+
1247  descriptor,
+
1248  paramsInfo);
+
1249 }
+
1250 
+
1251 bool NeonLayerSupport::IsMaximumSupported(const TensorInfo& input0,
+
1252  const TensorInfo& input1,
+
1253  const TensorInfo& output,
+
1254  Optional<std::string&> reasonIfUnsupported) const
+
1255 {
+
1256  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonMaximumWorkloadValidate,
+
1257  reasonIfUnsupported,
+
1258  input0,
+
1259  input1,
+
1260  output);
+
1261 }
+
1262 
+
1263 bool NeonLayerSupport::IsMeanSupported(const TensorInfo& input,
+
1264  const TensorInfo& output,
+
1265  const MeanDescriptor& descriptor,
+
1266  Optional<std::string&> reasonIfUnsupported) const
+
1267 {
+
1268  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonMeanWorkloadValidate,
+
1269  reasonIfUnsupported,
+
1270  input,
+
1271  output,
+
1272  descriptor);
+
1273 }
+
1274 
+
1275 bool NeonLayerSupport::IsMinimumSupported(const TensorInfo& input0,
+
1276  const TensorInfo& input1,
+
1277  const TensorInfo& output,
+
1278  Optional<std::string&> reasonIfUnsupported) const
+
1279 {
+
1280  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonMinimumWorkloadValidate,
+
1281  reasonIfUnsupported,
+
1282  input0,
+
1283  input1,
+
1284  output);
+
1285 }
+
1286 
+
1287 bool NeonLayerSupport::IsMultiplicationSupported(const TensorInfo& input0,
+
1288  const TensorInfo& input1,
+
1289  const TensorInfo& output,
+
1290  Optional<std::string&> reasonIfUnsupported) const
+
1291 {
+
1292  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonMultiplicationWorkloadValidate,
+
1293  reasonIfUnsupported,
+
1294  input0,
+
1295  input1,
+
1296  output,
+
1297  nullptr);
+
1298 }
+
1299 
+
1300 bool NeonLayerSupport::IsDivisionSupported(const TensorInfo& input0,
+
1301  const TensorInfo& input1,
+
1302  const TensorInfo& output,
+
1303  Optional<std::string&> reasonIfUnsupported) const
+
1304 {
+
1305  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonDivisionWorkloadValidate,
+
1306  reasonIfUnsupported,
+
1307  input0,
+
1308  input1,
+
1309  output,
+
1310  nullptr);
+
1311 }
+
1312 
+
1313 bool NeonLayerSupport::IsNormalizationSupported(const TensorInfo& input,
+
1314  const TensorInfo& output,
+
1315  const NormalizationDescriptor& descriptor,
+
1316  Optional<std::string&> reasonIfUnsupported) const
+
1317 {
+
1318  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonNormalizationWorkloadValidate,
+
1319  reasonIfUnsupported,
+
1320  input,
+
1321  output,
+
1322  descriptor);
+
1323 }
+
1324 
+
1325 bool NeonLayerSupport::IsOutputSupported(const TensorInfo& output,
+
1326  Optional<std::string&> reasonIfUnsupported) const
+
1327 {
+
1328  return IsNeonBackendSupported(reasonIfUnsupported, output);
+
1329 }
+
1330 
+
1331 bool NeonLayerSupport::IsPadSupported(const TensorInfo& input,
+
1332  const TensorInfo& output,
+
1333  const PadDescriptor& descriptor,
+
1334  Optional<std::string&> reasonIfUnsupported) const
+
1335 {
+
1336  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonPadWorkloadValidate,
+
1337  reasonIfUnsupported,
+
1338  input,
+
1339  output,
+
1340  descriptor);
+
1341 }
+
1342 
+
1343 bool NeonLayerSupport::IsPermuteSupported(const TensorInfo& input,
+
1344  const TensorInfo& output,
+
1345  const PermuteDescriptor& descriptor,
+
1346  Optional<std::string&> reasonIfUnsupported) const
+
1347 {
+
1348  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonPermuteWorkloadValidate, reasonIfUnsupported, input, output, descriptor);
+
1349 }
+
1350 
+
1351 bool NeonLayerSupport::IsPooling2dSupported(const TensorInfo& input,
+
1352  const TensorInfo& output,
+
1353  const Pooling2dDescriptor& descriptor,
+
1354  Optional<std::string&> reasonIfUnsupported) const
+
1355 {
+
1356  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonPooling2dWorkloadValidate, reasonIfUnsupported, input, output, descriptor);
+
1357 }
+
1358 
+
1359 bool NeonLayerSupport::IsPooling3dSupported(const TensorInfo& input,
+
1360  const TensorInfo& output,
+
1361  const Pooling3dDescriptor& descriptor,
+
1362  Optional<std::string&> reasonIfUnsupported) const
+
1363 {
+
1364  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonPooling3dWorkloadValidate, reasonIfUnsupported, input, output, descriptor);
+
1365 }
+
1366 
+
1367 bool NeonLayerSupport::IsPreluSupported(const armnn::TensorInfo &input,
+
1368  const armnn::TensorInfo &alpha,
+
1369  const armnn::TensorInfo &output,
+
1370  armnn::Optional<std::string &> reasonIfUnsupported) const
+
1371 {
+
1372  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonPreluWorkloadValidate, reasonIfUnsupported, input, alpha, output);
+
1373 }
+
1374 
+
1375 bool NeonLayerSupport::IsQLstmSupported(const TensorInfo& input,
+
1376  const TensorInfo& previousOutputIn,
+
1377  const TensorInfo& previousCellStateIn,
+
1378  const TensorInfo& outputStateOut,
+
1379  const TensorInfo& cellStateOut,
+
1380  const TensorInfo& output,
+
1381  const QLstmDescriptor& descriptor,
+
1382  const LstmInputParamsInfo& paramsInfo,
+
1383  Optional<std::string&> reasonIfUnsupported) const
+
1384 {
+
1385  // Check required here in order to pass IsLayerSupported for datatypes tests
+
1386  if (input.GetDataType() == armnn::DataType::QAsymmS8 &&
+
1387  previousOutputIn.GetDataType() == armnn::DataType::QAsymmS8 &&
+
1388  previousCellStateIn.GetDataType() == armnn::DataType::QSymmS16 &&
+
1389  outputStateOut.GetDataType() == armnn::DataType::QAsymmS8 &&
+
1390  cellStateOut.GetDataType() == armnn::DataType::QSymmS16 &&
+
1391  output.GetDataType() == armnn::DataType::QAsymmS8)
+
1392  {
+
1393  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonQLstmWorkloadValidate,
+
1394  reasonIfUnsupported,
+
1395  input,
+
1396  previousCellStateIn,
+
1397  previousOutputIn,
+
1398  cellStateOut,
+
1399  outputStateOut,
+
1400  output,
+
1401  descriptor,
+
1402  paramsInfo);
+
1403  }
+
1404  else
+
1405  {
+
1406  return false;
+
1407  }
+
1408 }
+
1409 
+
1410 bool NeonLayerSupport::IsQuantizeSupported(const TensorInfo& input,
+
1411  const TensorInfo& output,
+
1412  Optional<std::string&> reasonIfUnsupported) const
+
1413 {
+
1414  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonQuantizeWorkloadValidate,
+
1415  reasonIfUnsupported,
+
1416  input,
+
1417  output);
+
1418 }
+
1419 
+
1420 bool NeonLayerSupport::IsQuantizedLstmSupported(const TensorInfo& input,
+
1421  const TensorInfo& cellStateIn,
+
1422  const TensorInfo& outputStateIn,
+
1423  const TensorInfo& cellStateOut,
+
1424  const TensorInfo& outputStateOut,
+
1425  const QuantizedLstmInputParamsInfo& paramsInfo,
+
1426  Optional<std::string&> reasonIfUnsupported) const
+
1427 {
+
1428  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonQuantizedLstmWorkloadValidate,
+
1429  reasonIfUnsupported,
+
1430  input,
+
1431  cellStateIn,
+
1432  outputStateIn,
+
1433  cellStateOut,
+
1434  outputStateOut,
+
1435  paramsInfo);
+
1436 }
+
1437 
+
1438 bool NeonLayerSupport::IsReduceSupported(const TensorInfo& input,
+
1439  const TensorInfo& output,
+
1440  const ReduceDescriptor& descriptor,
+
1441  Optional<std::string&> reasonIfUnsupported) const
+
1442 {
+
1443  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonReduceWorkloadValidate,
+
1444  reasonIfUnsupported,
+
1445  input,
+
1446  output,
+
1447  descriptor);
+
1448 }
+
1449 
+
1450 bool NeonLayerSupport::IsReshapeSupported(const TensorInfo& input,
+
1451  const TensorInfo& output,
+
1452  const ReshapeDescriptor& descriptor,
+
1453  Optional<std::string&> reasonIfUnsupported) const
+
1454 {
+
1455  armnn::IgnoreUnused(descriptor);
+
1456  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonReshapeWorkloadValidate,
+
1457  reasonIfUnsupported,
+
1458  input,
+
1459  output);
+
1460 }
+
1461 
+
1462 bool NeonLayerSupport::IsResizeSupported(const TensorInfo& input,
+
1463  const TensorInfo& output,
+
1464  const ResizeDescriptor& descriptor,
+
1465  Optional<std::string&> reasonIfUnsupported) const
+
1466 {
+
1467  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonResizeWorkloadValidate,
+
1468  reasonIfUnsupported,
+
1469  input,
+
1470  output,
+
1471  descriptor);
+
1472 }
+
1473 
+
1474 bool NeonLayerSupport::IsSliceSupported(const TensorInfo& input,
+
1475  const TensorInfo& output,
+
1476  const SliceDescriptor& descriptor,
+
1477  Optional<std::string&> reasonIfUnsupported) const
+
1478 {
+
1479  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonSliceWorkloadValidate,
+
1480  reasonIfUnsupported,
+
1481  input,
+
1482  output,
+
1483  descriptor);
+
1484 }
+
1485 
+
1486 bool NeonLayerSupport::IsSoftmaxSupported(const TensorInfo& input,
+
1487  const TensorInfo& output,
+
1488  const SoftmaxDescriptor& descriptor,
+
1489  Optional<std::string&> reasonIfUnsupported) const
+
1490 {
+
1491  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonSoftmaxWorkloadValidate, reasonIfUnsupported, input, output, descriptor);
+
1492 }
+
1493 
+
1494 bool NeonLayerSupport::IsSpaceToBatchNdSupported(const TensorInfo& input,
+
1495  const TensorInfo& output,
+
1496  const SpaceToBatchNdDescriptor& descriptor,
+
1497  Optional<std::string&> reasonIfUnsupported) const
+
1498 {
+
1499  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonSpaceToBatchNdWorkloadValidate,
+
1500  reasonIfUnsupported,
+
1501  input,
+
1502  output,
+
1503  descriptor);
+
1504 }
+
1505 
+
1506 bool NeonLayerSupport::IsSpaceToDepthSupported(const TensorInfo& input,
+
1507  const TensorInfo& output,
+
1508  const SpaceToDepthDescriptor& descriptor,
+
1509  Optional<std::string&> reasonIfUnsupported) const
+
1510 {
+
1511  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonSpaceToDepthWorkloadValidate,
+
1512  reasonIfUnsupported,
+
1513  input,
+
1514  output,
+
1515  descriptor);
+
1516 }
+
1517 
+
1518 bool NeonLayerSupport::IsSplitterSupported(const TensorInfo& input,
+
1519  const std::vector<std::reference_wrapper<TensorInfo>>& outputs,
+
1520  const ViewsDescriptor& descriptor,
+
1521  Optional<std::string&> reasonIfUnsupported) const
+
1522 {
+
1523 #if defined(ARMCOMPUTENEON_ENABLED)
+
1524  // Split along the last dimension, cannot use sub-tensors
+
1525  // as width and height of the sub-tensors do not match
+
1526  // the width and height of the parent tensor
+
1527  // in case of input with more than 2D.
+
1528  std::set<unsigned int> splitAxis = ComputeSplitAxis(descriptor, input.GetShape());
+
1529  if (descriptor.GetNumDimensions() > 2 && splitAxis.size() == 1 &&
+
1530  *splitAxis.begin() == descriptor.GetNumDimensions() - 1 )
+
1531  {
+
1532  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonSplitterWorkloadValidate,
+
1533  reasonIfUnsupported,
+
1534  input,
+
1535  outputs,
+
1536  *splitAxis.begin());
+
1537  }
+
1538 #endif
+
1539  IgnoreUnused(descriptor);
+
1540  for (auto output : outputs)
+
1541  {
+
1542  if (!input.IsTypeSpaceMatch(output)) // Cannot use sub-tensors if the types are not same space
+
1543  {
+
1544  SetValueChecked(reasonIfUnsupported, "Neon Splitter: Types and quantization parameters must match.");
+
1545  return false;
+
1546  }
+
1547  }
+
1548  return true;
+
1549 }
+
1550 
+
1551 bool NeonLayerSupport::IsStackSupported(const std::vector<const TensorInfo*>& inputs,
+
1552  const TensorInfo& output,
+
1553  const StackDescriptor& descriptor,
+
1554  Optional<std::string&> reasonIfUnsupported) const
+
1555 {
+
1556  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonStackWorkloadValidate,
+
1557  reasonIfUnsupported,
+
1558  inputs,
+
1559  output,
+
1560  descriptor);
+
1561 }
+
1562 
+
1563 bool NeonLayerSupport::IsStridedSliceSupported(const TensorInfo& input,
+
1564  const TensorInfo& output,
+
1565  const StridedSliceDescriptor& descriptor,
+
1566  Optional<std::string&> reasonIfUnsupported) const
+
1567 {
+
1568  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonStridedSliceWorkloadValidate,
+
1569  reasonIfUnsupported,
+
1570  input,
+
1571  output,
+
1572  descriptor);
+
1573 }
+
1574 
+
1575 bool NeonLayerSupport::IsSubtractionSupported(const TensorInfo& input0,
+
1576  const TensorInfo& input1,
+
1577  const TensorInfo& output,
+
1578  Optional<std::string&> reasonIfUnsupported) const
+
1579 {
+
1580  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonSubtractionWorkloadValidate,
+
1581  reasonIfUnsupported,
+
1582  input0,
+
1583  input1,
+
1584  output,
+
1585  nullptr);
+
1586 }
+
1587 
+
1588 bool NeonLayerSupport::IsTransposeConvolution2dSupported(const TensorInfo& input,
+
1589  const TensorInfo& output,
+
1590  const TransposeConvolution2dDescriptor& descriptor,
+
1591  const TensorInfo& weights,
+
1592  const Optional<TensorInfo>& biases,
+
1593  Optional<std::string&> reasonIfUnsupported) const
+
1594 {
+
1595  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonTransposeConvolution2dWorkloadValidate,
+
1596  reasonIfUnsupported,
+
1597  input,
+
1598  output,
+
1599  descriptor,
+
1600  weights,
+
1601  biases);
+
1602 }
+
1603 
+
1604 bool NeonLayerSupport::IsTransposeSupported(const TensorInfo& input,
+
1605  const TensorInfo& output,
+
1606  const TransposeDescriptor& descriptor,
+
1607  Optional<std::string&> reasonIfUnsupported) const
+
1608 {
+
1609  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonTransposeWorkloadValidate, reasonIfUnsupported, input, output, descriptor);
+
1610 }
+
1611 
+
1612 bool NeonLayerSupport::IsUnidirectionalSequenceLstmSupported(const TensorInfo& input,
+
1613  const TensorInfo& outputStateIn,
+
1614  const TensorInfo& cellStateIn,
+
1615  const TensorInfo& outputStateOut,
+
1616  const TensorInfo& cellStateOut,
+
1617  const TensorInfo& output,
+
1618  const UnidirectionalSequenceLstmDescriptor& descriptor,
+
1619  const LstmInputParamsInfo& paramsInfo,
+
1620  Optional<std::string&> reasonIfUnsupported) const
+
1621 {
+
1622  if (input.GetDataType() == armnn::DataType::QAsymmS8 &&
+
1623  outputStateIn.GetDataType() == armnn::DataType::QAsymmS8 &&
+
1624  cellStateIn.GetDataType() == armnn::DataType::QSymmS16 &&
+
1625  outputStateOut.GetDataType() == armnn::DataType::QAsymmS8 &&
+
1626  cellStateOut.GetDataType() == armnn::DataType::QSymmS16 &&
+
1627  output.GetDataType() == armnn::DataType::QAsymmS8)
+
1628  {
+
1629  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonUnidirectionalSequenceLstmWorkloadValidate,
+
1630  reasonIfUnsupported,
+
1631  input,
+
1632  outputStateIn,
+
1633  cellStateIn,
+
1634  outputStateOut,
+
1635  cellStateOut,
+
1636  output,
+
1637  descriptor,
+
1638  paramsInfo);
+
1639  }
+
1640  else
+
1641  {
+
1642  FORWARD_WORKLOAD_VALIDATE_FUNC(NeonUnidirectionalSequenceLstmFloatWorkloadValidate,
+
1643  reasonIfUnsupported,
+
1644  input,
+
1645  outputStateIn,
+
1646  cellStateIn,
+
1647  outputStateOut,
+
1648  cellStateOut,
+
1649  output,
+
1650  descriptor,
+
1651  paramsInfo);
+
1652  }
+
1653 }
+
1654 
+
1655 } // namespace armnn
+
+
+
armnn::NeonLayerSupport::IsResizeSupported
bool IsResizeSupported(const TensorInfo &input, const TensorInfo &output, const ResizeDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1462
+
armnn::LayerSupportBase::IsMemImportSupported
bool IsMemImportSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: LayerSupportBase.cpp:397
+ +
armnn::NeonLayerSupport::IsBatchToSpaceNdSupported
bool IsBatchToSpaceNdSupported(const TensorInfo &input, const TensorInfo &output, const BatchToSpaceNdDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:808
+
armnn::NeonLayerSupport::IsPooling2dSupported
bool IsPooling2dSupported(const TensorInfo &input, const TensorInfo &output, const Pooling2dDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1351
+
armnn::NeonArgMinMaxWorkloadValidate
arm_compute::Status NeonArgMinMaxWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const ArgMinMaxDescriptor &descriptor)
Definition: NeonArgMinMaxWorkload.cpp:31
+
armnn::NeonSoftmaxWorkloadValidate
arm_compute::Status NeonSoftmaxWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const SoftmaxDescriptor &descriptor)
Definition: NeonSoftmaxWorkload.cpp:19
+ + +
armnn::NeonLayerSupport::IsElementwiseUnarySupported
bool IsElementwiseUnarySupported(const TensorInfo &input, const TensorInfo &output, const ElementwiseUnaryDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1046
+ + + + +
armnn::ILayerSupport::outputStateIn
const TensorInfo & outputStateIn
Definition: ILayerSupport.hpp:286
+ +
armnn::NeonSplitterWorkloadValidate
arm_compute::Status NeonSplitterWorkloadValidate(const TensorInfo &input, const std::vector< std::reference_wrapper< TensorInfo >> &outputs, unsigned int splitAxis)
Definition: NeonSplitterWorkload.cpp:32
+ + + +
armnn::NeonStridedSliceWorkloadValidate
arm_compute::Status NeonStridedSliceWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const StridedSliceDescriptor &descriptor)
Definition: NeonStridedSliceWorkload.cpp:19
+
armnn::ILayerSupport::paramsInfo
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo const LstmDescriptor const LstmInputParamsInfo & paramsInfo
Definition: ILayerSupport.hpp:293
+ +
armnn::GatherDescriptor
A GatherDescriptor for the GatherLayer.
Definition: Descriptors.hpp:932
+
armnn::NeonLayerSupport::IsCastSupported
bool IsCastSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:820
+
armnn::NormalizationDescriptor
A NormalizationDescriptor for the NormalizationLayer.
Definition: Descriptors.hpp:757
+
armnn::TransposeDescriptor
A TransposeDescriptor for the TransposeLayer.
Definition: Descriptors.hpp:1457
+ +
armnn::NeonLayerSupport::IsSoftmaxSupported
bool IsSoftmaxSupported(const TensorInfo &input, const TensorInfo &output, const SoftmaxDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1486
+
armnn::NeonLayerSupport::IsDepthToSpaceSupported
bool IsDepthToSpaceSupported(const TensorInfo &input, const TensorInfo &output, const DepthToSpaceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:990
+ + +
armnn::ElementwiseUnaryDescriptor
A ElementwiseUnaryDescriptor for the ElementwiseUnaryLayer.
Definition: Descriptors.hpp:129
+
armnn::NeonGatherNdWorkloadValidate
arm_compute::Status NeonGatherNdWorkloadValidate(const TensorInfo &paramsInfo, const TensorInfo &indicesInfo, const TensorInfo &outputInfo)
Definition: NeonGatherNdWorkload.cpp:14
+
armnn::PadDescriptor
A PadDescriptor for the PadLayer.
Definition: Descriptors.hpp:1163
+
armnn::SoftmaxDescriptor
A SoftmaxDescriptor for the SoftmaxLayer.
Definition: Descriptors.hpp:177
+ + +
armnn::NeonLayerSupport::IsArgMinMaxSupported
bool IsArgMinMaxSupported(const TensorInfo &input, const TensorInfo &output, const ArgMinMaxDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:745
+ + +
armnn::StackDescriptor
A StackDescriptor for the StackLayer.
Definition: Descriptors.hpp:1218
+ + +
armnn::SliceDescriptor
A SliceDescriptor for the SliceLayer.
Definition: Descriptors.hpp:1195
+
armnn::NeonBackendModelContext
The NeonBackendModelContext is used to pass in Neon specific backend ModelOptions.
Definition: NeonBackendModelContext.hpp:19
+
armnn::ILayerSupport::scratchBuffer
const TensorInfo const TensorInfo const TensorInfo & scratchBuffer
Definition: ILayerSupport.hpp:288
+ +
armnn::NeonLayerSupport::IsPermuteSupported
bool IsPermuteSupported(const TensorInfo &input, const TensorInfo &output, const PermuteDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1343
+ + +
armnn::NeonLayerSupport::IsSpaceToDepthSupported
bool IsSpaceToDepthSupported(const TensorInfo &input, const TensorInfo &output, const SpaceToDepthDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1506
+ + +
armnn::NeonQuantizeWorkloadValidate
arm_compute::Status NeonQuantizeWorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: NeonQuantizeWorkload.cpp:18
+ +
armnn::ActivationDescriptor
An ActivationDescriptor for the ActivationLayer.
Definition: Descriptors.hpp:36
+
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
+
armnn::LstmDescriptor
An LstmDescriptor for the LstmLayer.
Definition: Descriptors.hpp:1069
+
armnn::NeonLayerSupport::IsTransposeSupported
bool IsTransposeSupported(const TensorInfo &input, const TensorInfo &output, const TransposeDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1604
+ + + + +
armnn::FullyConnectedDescriptor
A FullyConnectedDescriptor for the FullyConnectedLayer.
Definition: Descriptors.hpp:495
+ + +
armnn::NeonPadWorkloadValidate
arm_compute::Status NeonPadWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const PadDescriptor &descriptor)
Definition: NeonPadWorkload.cpp:59
+
armnn::NeonLayerSupport::IsSplitterSupported
bool IsSplitterSupported(const TensorInfo &input, const std::vector< std::reference_wrapper< TensorInfo >> &outputs, const ViewsDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1518
+
armnn::NeonAbsWorkloadValidate
arm_compute::Status NeonAbsWorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: NeonAbsWorkload.cpp:17
+
armnn::NeonConvertFp16ToFp32WorkloadValidate
arm_compute::Status NeonConvertFp16ToFp32WorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: NeonConvertFp16ToFp32Workload.cpp:19
+ + +
armnn::BatchMatMulDescriptor
A BatchMatMulDescriptor for the BatchMatMul operator.
Definition: Descriptors.hpp:1551
+
armnn::ResizeDescriptor
A ResizeDescriptor for the ResizeLayer.
Definition: Descriptors.hpp:952
+ + +
armnn::StridedSliceDescriptor
A StridedSliceDescriptor for the StridedSliceLayer.
Definition: Descriptors.hpp:1270
+ + +
armnn::NeonLayerSupport::IsMinimumSupported
bool IsMinimumSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1275
+ + + +
armnn::Pooling3dDescriptor
A Pooling3dDescriptor for the Pooling3dLayer.
Definition: Descriptors.hpp:419
+
armnn::ReduceDescriptor
A ReduceDescriptor for the REDUCE operators.
Definition: Descriptors.hpp:1505
+
armnn::NeonLogicalAndWorkloadValidate
arm_compute::Status NeonLogicalAndWorkloadValidate(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output)
Definition: NeonLogicalAndWorkload.cpp:18
+ + +
armnn::ILayerSupport::previousOutputIn
const TensorInfo & previousOutputIn
Definition: ILayerSupport.hpp:405
+ + +
armnn::ComparisonDescriptor
A ComparisonDescriptor for the ComparisonLayer.
Definition: Descriptors.hpp:89
+
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
+ + + +
armnn::NeonConvolution2dWorkloadValidate
arm_compute::Status NeonConvolution2dWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const Convolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, bool isFastMathEnabled, const ActivationDescriptor *activationDescriptor)
Definition: NeonConvolution2dWorkload.cpp:24
+
armnn::NeonTransposeConvolution2dWorkloadValidate
arm_compute::Status NeonTransposeConvolution2dWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const TransposeConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases)
Definition: NeonTransposeConvolution2dWorkload.cpp:25
+
armnn::ILayerSupport::mean
const TensorInfo const TensorInfo & mean
Definition: ILayerSupport.hpp:63
+ +
armnn::NeonPooling3dWorkloadValidate
arm_compute::Status NeonPooling3dWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const Pooling3dDescriptor &descriptor)
Definition: NeonPooling3dWorkload.cpp:15
+
armnn::LayerSupportBase::IsMergeSupported
bool IsMergeSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: LayerSupportBase.cpp:404
+ +
armnn::LayerSupportBase::IsShapeSupported
bool IsShapeSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: LayerSupportBase.cpp:551
+
armnn::ViewsDescriptor
A ViewsDescriptor for the SplitterLayer.
Definition: Descriptors.hpp:244
+
armnn::NeonCastValidate
arm_compute::Status NeonCastValidate(const TensorInfo &input, const TensorInfo &output)
Definition: NeonCastWorkload.cpp:19
+ +
armnn::NeonLayerSupport::IsComparisonSupported
bool IsComparisonSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ComparisonDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:842
+ + +
armnn::NeonSpaceToBatchNdWorkloadValidate
arm_compute::Status NeonSpaceToBatchNdWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const SpaceToBatchNdDescriptor &descriptor)
Definition: NeonSpaceToBatchNdWorkload.cpp:20
+ + +
armnn::NeonLogWorkloadValidate
arm_compute::Status NeonLogWorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: NeonLogWorkload.cpp:17
+ + + + +
armnn::NeonLayerSupport::IsDivisionSupported
bool IsDivisionSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1300
+ +
armnn::NeonLayerSupport::IsStackSupported
bool IsStackSupported(const std::vector< const TensorInfo * > &inputs, const TensorInfo &output, const StackDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1551
+ +
armnn::NeonLayerSupport::IsMeanSupported
bool IsMeanSupported(const TensorInfo &input, const TensorInfo &output, const MeanDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1263
+
armnn::NeonActivationWorkloadValidate
arm_compute::Status NeonActivationWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const ActivationDescriptor &descriptor)
Definition: NeonActivationWorkload.cpp:17
+ + +
armnn::NeonLayerSupport::IsMultiplicationSupported
bool IsMultiplicationSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1287
+ +
armnn::NeonLayerSupport::IsQuantizeSupported
bool IsQuantizeSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1410
+
armnn
Copyright (c) 2021 ARM Limited and Contributors.
Definition: 01_00_quick_start.dox:6
+ +
armnn::NeonLayerSupport::IsSpaceToBatchNdSupported
bool IsSpaceToBatchNdSupported(const TensorInfo &input, const TensorInfo &output, const SpaceToBatchNdDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1494
+ +
armnn::NeonAdditionWorkloadValidate
arm_compute::Status NeonAdditionWorkloadValidate(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ActivationDescriptor *activationDescriptor)
Definition: NeonAdditionWorkload.cpp:20
+
armnn::NeonFullyConnectedWorkloadValidate
arm_compute::Status NeonFullyConnectedWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const TensorInfo &weights, const Optional< TensorInfo > &biases, const FullyConnectedDescriptor &descriptor, const ActivationDescriptor *activationDescriptor)
Definition: NeonFullyConnectedWorkload.cpp:24
+
armnn::NeonLayerSupport::IsNormalizationSupported
bool IsNormalizationSupported(const TensorInfo &input, const TensorInfo &output, const NormalizationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1313
+ +
armnn::NeonLayerSupport::IsBatchNormalizationSupported
bool IsBatchNormalizationSupported(const TensorInfo &input, const TensorInfo &output, const TensorInfo &mean, const TensorInfo &var, const TensorInfo &beta, const TensorInfo &gamma, const BatchNormalizationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:787
+
armnn::SetValueChecked
void SetValueChecked(Optional< T & > optionalRef, V &&val)
Definition: LayerSupportCommon.hpp:17
+ +
armnn::BatchToSpaceNdDescriptor
A BatchToSpaceNdDescriptor for the BatchToSpaceNdLayer.
Definition: Descriptors.hpp:863
+
armnn::ComputeSplitAxis
std::set< unsigned int > ComputeSplitAxis(const armnn::SplitterDescriptor &desc, const TensorShape &input)
Definition: ArmComputeUtils.hpp:244
+ + +
armnn::SpaceToDepthDescriptor
A SpaceToDepthDescriptor for the SpaceToDepthLayer.
Definition: Descriptors.hpp:1042
+ + +
armnn::NeonLayerSupport::IsDepthwiseConvolutionSupported
bool IsDepthwiseConvolutionSupported(const TensorInfo &input, const TensorInfo &output, const DepthwiseConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1002
+ + +
armnn::NeonLayerSupport::IsTransposeConvolution2dSupported
bool IsTransposeConvolution2dSupported(const TensorInfo &input, const TensorInfo &output, const TransposeConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1588
+ + +
armnn::NeonConstantWorkloadValidate
arm_compute::Status NeonConstantWorkloadValidate(const TensorInfo &output)
Definition: NeonConstantWorkload.cpp:20
+ +
armnn::NeonL2NormalizationWorkloadValidate
arm_compute::Status NeonL2NormalizationWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const L2NormalizationDescriptor &descriptor)
Definition: NeonL2NormalizationFloatWorkload.cpp:19
+
armnn::NeonLayerSupport::IsBatchMatMulSupported
bool IsBatchMatMulSupported(const TensorInfo &inputX, const TensorInfo &inputY, const TensorInfo &output, const BatchMatMulDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: NeonLayerSupport.cpp:757
+ + +
armnn::NeonDequantizeWorkloadValidate
arm_compute::Status NeonDequantizeWorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: NeonDequantizeWorkload.cpp:22
+ +
armnn::NeonLayerSupport::IsInstanceNormalizationSupported
bool IsInstanceNormalizationSupported(const TensorInfo &input, const TensorInfo &output, const InstanceNormalizationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1174
+ + +
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:42
+
armnn::NeonLayerSupport::IsConstantSupported
bool IsConstantSupported(const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:896
+
armnn::LayerSupportBase::IsDetectionPostProcessSupported
bool IsDetectionPostProcessSupported(const TensorInfo &boxEncodings, const TensorInfo &scores, const TensorInfo &anchors, const TensorInfo &detectionBoxes, const TensorInfo &detectionClasses, const TensorInfo &detectionScores, const TensorInfo &numDetections, const DetectionPostProcessDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: LayerSupportBase.cpp:233
+
armnn::FillDescriptor
A FillDescriptor for the FillLayer.
Definition: Descriptors.hpp:913
+ +
armnn::NeonDepthToSpaceWorkloadValidate
arm_compute::Status NeonDepthToSpaceWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const DepthToSpaceDescriptor &descriptor)
Definition: NeonDepthToSpaceWorkload.cpp:19
+
armnn::LayerType
LayerType
When adding a new layer, adapt also the LastLayer enum value in the enum class LayerType below.
Definition: Types.hpp:479
+ +
armnn::NeonLayerSupport::IsOutputSupported
bool IsOutputSupported(const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1325
+
armnn::NeonLayerSupport::IsSliceSupported
bool IsSliceSupported(const TensorInfo &input, const TensorInfo &output, const SliceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1474
+
armnn::IBackendInternal::IBackendSpecificModelContextPtr
std::shared_ptr< IBackendModelContext > IBackendSpecificModelContextPtr
Definition: IBackendInternal.hpp:96
+
armnn::ILayerSupport::previousCellStateIn
const TensorInfo const TensorInfo & previousCellStateIn
Definition: ILayerSupport.hpp:406
+ + + +
armnn::NeonResizeWorkloadValidate
arm_compute::Status NeonResizeWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const ResizeDescriptor &descriptor)
Definition: NeonResizeWorkload.cpp:22
+ +
armnn::NeonBatchMatMulValidate
arm_compute::Status NeonBatchMatMulValidate(const TensorInfo &inputInfoX, const TensorInfo &inputInfoY, const TensorInfo &outputInfo, const BatchMatMulDescriptor &descriptor, const bool isFastMathEnabled, const ActivationDescriptor *activationDescriptor)
Definition: NeonBatchMatMulWorkload.cpp:17
+ + +
armnn::NeonBatchNormalizationValidate
arm_compute::Status NeonBatchNormalizationValidate(const TensorInfo &input, const TensorInfo &output, const TensorInfo &mean, const TensorInfo &var, const TensorInfo &beta, const TensorInfo &gamma, const BatchNormalizationDescriptor &descriptor, const ActivationDescriptor *activationDescriptor)
Definition: NeonBatchNormalizationWorkload.cpp:24
+ +
armnn::ILayerSupport::alpha
const TensorInfo & alpha
Definition: ILayerSupport.hpp:392
+ +
armnn::NeonMeanWorkloadValidate
arm_compute::Status NeonMeanWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const MeanDescriptor &descriptor)
Definition: NeonMeanWorkload.cpp:18
+
armnn::NeonLayerSupport::IsReduceSupported
bool IsReduceSupported(const TensorInfo &input, const TensorInfo &output, const ReduceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1438
+
armnn::NeonNegWorkloadValidate
arm_compute::Status NeonNegWorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: NeonNegWorkload.cpp:17
+ +
armnn::DepthwiseConvolution2dDescriptor
A DepthwiseConvolution2dDescriptor for the DepthwiseConvolution2dLayer.
Definition: Descriptors.hpp:647
+
armnn::MeanDescriptor
A MeanDescriptor for the MeanLayer.
Definition: Descriptors.hpp:1139
+
armnn::TensorInfo::GetNumDimensions
unsigned int GetNumDimensions() const
Definition: Tensor.hpp:195
+
armnn::NeonInstanceNormalizationWorkloadValidate
arm_compute::Status NeonInstanceNormalizationWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const InstanceNormalizationDescriptor &descriptor)
Definition: NeonInstanceNormalizationWorkload.cpp:19
+ + +
armnn::NeonLayerSupport::IsChannelShuffleSupported
bool IsChannelShuffleSupported(const TensorInfo &input, const TensorInfo &output, const ChannelShuffleDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:830
+
armnn::NeonConcatWorkloadValidate
arm_compute::Status NeonConcatWorkloadValidate(const std::vector< const TensorInfo * > &inputs, const TensorInfo &output, const OriginsDescriptor &descriptor)
Definition: NeonConcatWorkload.cpp:27
+ +
armnn::TensorInfo::IsTypeSpaceMatch
bool IsTypeSpaceMatch(const TensorInfo &other) const
Check that the types are the same and, if quantize, that the quantization parameters are the same.
Definition: Tensor.cpp:432
+ + +
armnn::NeonLayerSupport::IsLstmSupported
bool IsLstmSupported(const TensorInfo &input, const TensorInfo &outputStateIn, const TensorInfo &cellStateIn, const TensorInfo &scratchBuffer, const TensorInfo &outputStateOut, const TensorInfo &cellStateOut, const TensorInfo &output, const LstmDescriptor &descriptor, const LstmInputParamsInfo &paramsInfo, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1227
+ +
armnn::NeonLayerSupport::IsReshapeSupported
bool IsReshapeSupported(const TensorInfo &input, const TensorInfo &output, const ReshapeDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1450
+
armnn::NeonSliceWorkloadValidate
arm_compute::Status NeonSliceWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const SliceDescriptor &descriptor)
Definition: NeonSliceWorkload.cpp:21
+ + +
armnn::NeonReduceWorkloadValidate
arm_compute::Status NeonReduceWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const ReduceDescriptor &descriptor)
Definition: NeonReduceWorkload.cpp:19
+
armnn::L2NormalizationDescriptor
A L2NormalizationDescriptor for the L2NormalizationLayer.
Definition: Descriptors.hpp:797
+
armnn::NeonLayerSupport::IsL2NormalizationSupported
bool IsL2NormalizationSupported(const TensorInfo &input, const TensorInfo &output, const L2NormalizationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1186
+ + +
armnn::ILayerSupport::input1
const TensorInfo & input1
Definition: ILayerSupport.hpp:48
+
armnn::NeonBatchToSpaceNdWorkloadValidate
arm_compute::Status NeonBatchToSpaceNdWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const BatchToSpaceNdDescriptor &descriptor)
Definition: NeonBatchToSpaceNdWorkload.cpp:20
+
armnn::ChannelShuffleDescriptor
A ChannelShuffleDescriptor for the ChannelShuffle operator.
Definition: Descriptors.hpp:1529
+
armnn::NeonQuantizedLstmWorkloadValidate
arm_compute::Status NeonQuantizedLstmWorkloadValidate(const TensorInfo &input, const TensorInfo &cellStateIn, const TensorInfo &outputStateIn, const TensorInfo &cellStateOut, const TensorInfo &outputStateOut, const QuantizedLstmInputParamsInfo &paramsInfo)
Definition: NeonQuantizedLstmWorkload.cpp:131
+
armnn::Convolution3dDescriptor
A Convolution3dDescriptor for the Convolution3dLayer.
Definition: Descriptors.hpp:576
+ +
armnn::NeonGatherWorkloadValidate
arm_compute::Status NeonGatherWorkloadValidate(const TensorInfo &input, const TensorInfo &indices, const TensorInfo &output, const GatherDescriptor &descriptor)
Definition: NeonGatherWorkload.cpp:13
+ + +
armnn::ILayerSupport::gamma
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo & gamma
Definition: ILayerSupport.hpp:66
+ + + +
armnn::ILayerSupport::var
const TensorInfo const TensorInfo const TensorInfo & var
Definition: ILayerSupport.hpp:64
+ + +
armnn::NeonMinimumWorkloadValidate
arm_compute::Status NeonMinimumWorkloadValidate(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output)
Validate function for validating the inputs and output.
Definition: NeonMinimumWorkload.cpp:15
+
armnn::Convolution2dDescriptor
A Convolution2dDescriptor for the Convolution2dLayer.
Definition: Descriptors.hpp:522
+ +
armnn::NeonUnidirectionalSequenceLstmFloatWorkloadValidate
arm_compute::Status NeonUnidirectionalSequenceLstmFloatWorkloadValidate(const TensorInfo &input, const TensorInfo &outputStateIn, const TensorInfo &cellStateIn, const TensorInfo &outputStateOut, const TensorInfo &cellStateOut, const TensorInfo &output, const UnidirectionalSequenceLstmDescriptor &descriptor, const LstmInputParamsInfo &paramsInfo)
Definition: NeonUnidirectionalSequenceLstmFloatWorkload.cpp:510
+
armnn::NeonReshapeWorkloadValidate
arm_compute::Status NeonReshapeWorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: NeonReshapeWorkload.cpp:17
+
armnn::NeonLayerSupport::IsPreluSupported
bool IsPreluSupported(const TensorInfo &input, const TensorInfo &alpha, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1367
+
armnn::BatchNormalizationDescriptor
A BatchNormalizationDescriptor for the BatchNormalizationLayer.
Definition: Descriptors.hpp:816
+
armnn::NeonPreluWorkloadValidate
arm_compute::Status NeonPreluWorkloadValidate(const TensorInfo &input, const TensorInfo &alpha, const TensorInfo &output)
Definition: NeonPreluWorkload.cpp:17
+ +
armnn::QLstmDescriptor
A QLstmDescriptor for the QLstmLayer.
Definition: Descriptors.hpp:1347
+ + +
armnn::NeonLayerSupport::IsAdditionSupported
bool IsAdditionSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:732
+ + +
armnn::NeonUnidirectionalSequenceLstmWorkloadValidate
arm_compute::Status NeonUnidirectionalSequenceLstmWorkloadValidate(const TensorInfo &input, const TensorInfo &outputStateIn, const TensorInfo &cellStateIn, const TensorInfo &outputStateOut, const TensorInfo &cellStateOut, const TensorInfo &output, const UnidirectionalSequenceLstmDescriptor &descriptor, const LstmInputParamsInfo &paramsInfo)
Definition: NeonUnidirectionalSequenceLstmWorkload.cpp:491
+
armnn::EmptyOptional
EmptyOptional is used to initialize the Optional class in case we want to have default value for an O...
Definition: Optional.hpp:32
+
armnn::NeonLayerSupport::IsInputSupported
bool IsInputSupported(const TensorInfo &input, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1168
+
armnn::Status
Status
Definition: Types.hpp:42
+ + +
armnn::NeonLayerSupport::IsConvertFp16ToFp32Supported
bool IsConvertFp16ToFp32Supported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:904
+ +
armnn::TensorInfo::GetShape
const TensorShape & GetShape() const
Definition: Tensor.hpp:191
+ +
armnn::ILayerSupport::beta
const TensorInfo const TensorInfo const TensorInfo const TensorInfo & beta
Definition: ILayerSupport.hpp:65
+
armnn::NeonSubtractionWorkloadValidate
arm_compute::Status NeonSubtractionWorkloadValidate(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ActivationDescriptor *activationDescriptor)
Definition: NeonSubtractionWorkload.cpp:22
+ +
armnn::NeonRsqrtWorkloadValidate
arm_compute::Status NeonRsqrtWorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: NeonRsqrtWorkload.cpp:18
+
armnn::NeonLayerSupport::IsConcatSupported
bool IsConcatSupported(const std::vector< const TensorInfo * > inputs, const TensorInfo &output, const OriginsDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:857
+ +
armnn::NeonLayerSupport::IsActivationSupported
bool IsActivationSupported(const TensorInfo &input, const TensorInfo &output, const ActivationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:719
+ + +
armnn::NeonLayerSupport::IsConvertFp32ToFp16Supported
bool IsConvertFp32ToFp16Supported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:914
+
armnn::NeonLayerSupport::IsLogSoftmaxSupported
bool IsLogSoftmaxSupported(const TensorInfo &input, const TensorInfo &output, const LogSoftmaxDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1219
+ + +
armnn::ILayerSupport::weights
const TensorInfo const Convolution2dDescriptor const TensorInfo & weights
Definition: ILayerSupport.hpp:127
+ + + +
armnn::ILayerSupport::cellStateIn
const TensorInfo const TensorInfo & cellStateIn
Definition: ILayerSupport.hpp:287
+ + +
armnn::NeonLayerSupport::IsFillSupported
bool IsFillSupported(const TensorInfo &input, const TensorInfo &output, const FillDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1098
+ +
armnn::NeonChannelShuffleValidate
arm_compute::Status NeonChannelShuffleValidate(const TensorInfo &input, const TensorInfo &output, const ChannelShuffleDescriptor &descriptor)
Definition: NeonChannelShuffleWorkload.cpp:17
+ +
armnn::ILayerSupport::biases
const TensorInfo const Convolution2dDescriptor const TensorInfo const Optional< TensorInfo > & biases
Definition: ILayerSupport.hpp:128
+
armnn::NeonLayerSupport::IsFloorSupported
bool IsFloorSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1110
+ +
armnn::NeonConvertFp32ToFp16WorkloadValidate
arm_compute::Status NeonConvertFp32ToFp16WorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: NeonConvertFp32ToFp16Workload.cpp:21
+
armnn::NeonSpaceToDepthWorkloadValidate
arm_compute::Status NeonSpaceToDepthWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const SpaceToDepthDescriptor &descriptor)
Definition: NeonSpaceToDepthWorkload.cpp:19
+
armnn::NeonLayerSupport::IsGatherNdSupported
bool IsGatherNdSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported) const
Definition: NeonLayerSupport.cpp:1156
+ +
armnn::BaseDescriptor
Base class for all descriptors.
Definition: Descriptors.hpp:22
+ +
armnn::OriginsDescriptor
An OriginsDescriptor for the ConcatLayer.
Definition: Descriptors.hpp:201
+
armnn::NeonPermuteWorkloadValidate
arm_compute::Status NeonPermuteWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const PermuteDescriptor &descriptor)
Definition: NeonPermuteWorkload.cpp:15
+
armnn::ReshapeDescriptor
A ReshapeDescriptor for the ReshapeLayer.
Definition: Descriptors.hpp:990
+
armnn::IsLayerTypeSupported
bool IsLayerTypeSupported(const LayerType &type, const std::vector< TensorInfo > &infos, const BaseDescriptor &descriptor, const Optional< LstmInputParamsInfo > &lstmParamsInfo, const Optional< QuantizedLstmInputParamsInfo > &quantizedLstmParamsInfo, Optional< std::string & > reasonIfUnsupported, const NeonLayerSupport &support)
Definition: NeonLayerSupport.cpp:169
+ + +
armnn::NeonLayerSupport::IsConvolution3dSupported
bool IsConvolution3dSupported(const TensorInfo &input, const TensorInfo &output, const Convolution3dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:957
+
armnn::DataType
DataType
Definition: Types.hpp:48
+
armnn::PermuteDescriptor
A PermuteDescriptor for the PermuteLayer.
Definition: Descriptors.hpp:149
+
armnn::NeonLayerSupport::IsStridedSliceSupported
bool IsStridedSliceSupported(const TensorInfo &input, const TensorInfo &output, const StridedSliceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1563
+
armnn::TransposeConvolution2dDescriptor
A TransposeConvolution2dDescriptor for the TransposeConvolution2dLayer.
Definition: Descriptors.hpp:1407
+ +
armnn::IsSupportedForDataTypeGeneric
bool IsSupportedForDataTypeGeneric(Optional< std::string & > reasonIfUnsupported, DataType dataType, Float16Func float16FuncPtr, Float32Func float32FuncPtr, Uint8Func uint8FuncPtr, Int32Func int32FuncPtr, BooleanFunc booleanFuncPtr, Params &&... params)
Definition: LayerSupportCommon.hpp:27
+ +
armnn::NeonExpWorkloadValidate
arm_compute::Status NeonExpWorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: NeonExpWorkload.cpp:17
+
armnn::NeonSinWorkloadValidate
arm_compute::Status NeonSinWorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: NeonSinWorkload.cpp:17
+
armnn::NeonSqrtWorkloadValidate
arm_compute::Status NeonSqrtWorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: NeonSqrtWorkload.cpp:18
+
armnn::NeonLayerSupport::IsUnidirectionalSequenceLstmSupported
bool IsUnidirectionalSequenceLstmSupported(const TensorInfo &input, const TensorInfo &outputStateIn, const TensorInfo &cellStateIn, const TensorInfo &outputStateOut, const TensorInfo &cellStateOut, const TensorInfo &output, const UnidirectionalSequenceLstmDescriptor &descriptor, const LstmInputParamsInfo &paramsInfo, Optional< std::string & > reasonIfUnsupported) const override
Definition: NeonLayerSupport.cpp:1612
+
armnn::NeonTransposeWorkloadValidate
arm_compute::Status NeonTransposeWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const TransposeDescriptor &descriptor)
Definition: NeonTransposeWorkload.cpp:15
+ +
armnn::ILayerSupport::outputs
const std::vector< std::reference_wrapper< TensorInfo > > & outputs
Definition: ILayerSupport.hpp:488
+
armnn::NeonLayerSupport::IsGatherSupported
bool IsGatherSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const GatherDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported) const override
Definition: NeonLayerSupport.cpp:1142
+
armnn::Pooling2dDescriptor
A Pooling2dDescriptor for the Pooling2dLayer.
Definition: Descriptors.hpp:359
+
armnn::LogicalBinaryDescriptor
A LogicalBinaryDescriptor for the LogicalBinaryLayer.
Definition: Descriptors.hpp:1485
+ + + + + +
armnn::NeonQLstmWorkloadValidate
arm_compute::Status NeonQLstmWorkloadValidate(const TensorInfo &input, const TensorInfo &cellStateIn, const TensorInfo &outputStateIn, const TensorInfo &cellStateOut, const TensorInfo &outputStateOut, const TensorInfo &output, const QLstmDescriptor &descriptor, const LstmInputParamsInfo &paramsInfo)
Definition: NeonQLstmWorkload.cpp:243
+
armnn::NeonLayerSupport::IsLogicalBinarySupported
bool IsLogicalBinarySupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const LogicalBinaryDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported) const override
Definition: NeonLayerSupport.cpp:1194
+
armnn::NeonStackWorkloadValidate
arm_compute::Status NeonStackWorkloadValidate(const std::vector< const TensorInfo * > &inputs, const TensorInfo &output, const StackDescriptor &descriptor)
Definition: NeonStackWorkload.cpp:27
+
armnn::NeonDivisionWorkloadValidate
arm_compute::Status NeonDivisionWorkloadValidate(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ActivationDescriptor *activationDescriptor)
Definition: NeonDivisionWorkload.cpp:18
+
armnn::PolymorphicDowncast
DestType PolymorphicDowncast(SourceType *value)
Polymorphic downcast for build in pointers only.
Definition: PolymorphicDowncast.hpp:74
+
armnn::NeonLayerSupport::IsSubtractionSupported
bool IsSubtractionSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1575
+
armnn::NeonLayerSupport::IsDequantizeSupported
bool IsDequantizeSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1019
+
FORWARD_WORKLOAD_VALIDATE_FUNC
#define FORWARD_WORKLOAD_VALIDATE_FUNC(func, reasonIfUnsupported,...)
Definition: NeonLayerSupport.cpp:151
+
armnn::NeonConvolution3dWorkloadValidate
arm_compute::Status NeonConvolution3dWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const Convolution3dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, bool isFastMathEnabled, const ActivationDescriptor *activationDescriptor)
Definition: NeonConvolution3dWorkload.cpp:24
+ +
armnn::NeonLayerSupport::IsDilatedDepthwiseConvolutionSupported
bool IsDilatedDepthwiseConvolutionSupported(const TensorInfo &input, const TensorInfo &output, const DepthwiseConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string & > reason=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1029
+
armnn::ArgMinMaxDescriptor
An ArgMinMaxDescriptor for ArgMinMaxLayer.
Definition: Descriptors.hpp:67
+ + +
armnn::NeonMultiplicationWorkloadValidate
arm_compute::Status NeonMultiplicationWorkloadValidate(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ActivationDescriptor *activationDescriptor)
Definition: NeonMultiplicationWorkload.cpp:19
+
armnn::NeonLayerSupport::IsQLstmSupported
bool IsQLstmSupported(const TensorInfo &input, const TensorInfo &previousOutputIn, const TensorInfo &previousCellStateIn, const TensorInfo &outputStateOut, const TensorInfo &cellStateOut, const TensorInfo &output, const QLstmDescriptor &descriptor, const LstmInputParamsInfo &paramsInfo, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1375
+ + + + + + +
armnn::NeonLayerSupport::IsPooling3dSupported
bool IsPooling3dSupported(const TensorInfo &input, const TensorInfo &output, const Pooling3dDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1359
+ +
armnn::NeonLayerSupport::IsQuantizedLstmSupported
bool IsQuantizedLstmSupported(const TensorInfo &input, const TensorInfo &cellStateIn, const TensorInfo &outputStateIn, const TensorInfo &cellStateOut, const TensorInfo &outputStateOut, const QuantizedLstmInputParamsInfo &paramsInfo, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1420
+
armnn::NeonMaximumWorkloadValidate
arm_compute::Status NeonMaximumWorkloadValidate(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output)
Definition: NeonMaximumWorkload.cpp:14
+
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
+ + +
armnn::NeonLogicalOrWorkloadValidate
arm_compute::Status NeonLogicalOrWorkloadValidate(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output)
Definition: NeonLogicalOrWorkload.cpp:18
+ +
armnn::NeonLayerSupport::IsMaximumSupported
bool IsMaximumSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1251
+
armnn::NeonComparisonWorkloadValidate
arm_compute::Status NeonComparisonWorkloadValidate(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ComparisonDescriptor &descriptor)
Definition: NeonComparisonWorkload.cpp:16
+ +
armnn::NeonLayerSupport::IsFullyConnectedSupported
bool IsFullyConnectedSupported(const TensorInfo &input, const TensorInfo &output, const TensorInfo &weights, const TensorInfo &biases, const FullyConnectedDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1125
+
armnn::NeonNormalizationWorkloadValidate
arm_compute::Status NeonNormalizationWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const NormalizationDescriptor &descriptor)
Definition: NeonNormalizationFloatWorkload.cpp:49
+ + + + + +
armnn::ILayerSupport::outputStateOut
const TensorInfo const TensorInfo const TensorInfo const TensorInfo & outputStateOut
Definition: ILayerSupport.hpp:289
+
armnn::InstanceNormalizationDescriptor
An InstanceNormalizationDescriptor for InstanceNormalizationLayer.
Definition: Descriptors.hpp:835
+
armnn::NeonPooling2dWorkloadValidate
arm_compute::Status NeonPooling2dWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const Pooling2dDescriptor &descriptor)
Definition: NeonPooling2dWorkload.cpp:22
+
armnn::NeonDepthwiseConvolutionWorkloadValidate
arm_compute::Status NeonDepthwiseConvolutionWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const DepthwiseConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, const ActivationDescriptor *activationDescriptor)
Definition: NeonDepthwiseConvolutionWorkload.cpp:29
+ + +
armnn::ILayerSupport::cellStateOut
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo & cellStateOut
Definition: ILayerSupport.hpp:290
+
armnn::NeonLayerSupport::IsPadSupported
bool IsPadSupported(const TensorInfo &input, const TensorInfo &output, const PadDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:1331
+ +
armnn::LayerSupportBase::IsMemCopySupported
bool IsMemCopySupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: LayerSupportBase.cpp:390
+
armnn::TensorInfo::GetDataType
DataType GetDataType() const
Definition: Tensor.hpp:198
+
armnn::NeonLayerSupport::IsLayerSupported
bool IsLayerSupported(const LayerType &type, const std::vector< TensorInfo > &infos, const BaseDescriptor &descriptor, const Optional< LstmInputParamsInfo > &lstmParamsInfo, const Optional< QuantizedLstmInputParamsInfo > &quantizedLstmParamsInfo, Optional< std::string & > reasonIfUnsupported) const override
Definition: NeonLayerSupport.cpp:671
+ +
armnn::NeonLogSoftmaxWorkloadValidate
arm_compute::Status NeonLogSoftmaxWorkloadValidate(const TensorInfo &input, const TensorInfo &output, const LogSoftmaxDescriptor &descriptor)
Definition: NeonLogSoftmaxWorkload.cpp:19
+ +
armnn::NeonLogicalNotWorkloadValidate
arm_compute::Status NeonLogicalNotWorkloadValidate(const TensorInfo &input, const TensorInfo &output)
Definition: NeonLogicalNotWorkload.cpp:19
+
armnn::NeonLstmFloatWorkloadValidate
arm_compute::Status NeonLstmFloatWorkloadValidate(const TensorInfo &input, const TensorInfo &outputStateIn, const TensorInfo &cellStateIn, const TensorInfo &scratchBuffer, const TensorInfo &outputStateOut, const TensorInfo &cellStateOut, const TensorInfo &output, const LstmDescriptor &descriptor, const LstmInputParamsInfo &paramsInfo)
Definition: NeonLstmFloatWorkload.cpp:253
+ +
armnn::SpaceToBatchNdDescriptor
A SpaceToBatchNdDescriptor for the SpaceToBatchNdLayer.
Definition: Descriptors.hpp:1010
+
armnn::NeonLayerSupport::IsConvolution2dSupported
bool IsConvolution2dSupported(const TensorInfo &input, const TensorInfo &output, const Convolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const override
Definition: NeonLayerSupport.cpp:924
+ + + + + -- cgit v1.2.1