ArmNN
 22.02
ILayerSupport.cpp
Go to the documentation of this file.
1 //
2 // Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
3 // SPDX-License-Identifier: MIT
4 //
5 
6 #include <armnn/Types.hpp>
7 #include <armnn/utility/PolymorphicDowncast.hpp>
8 #include <armnn/Tensor.hpp>
9 #include <armnn/backends/ILayerSupport.hpp>
10 #include <armnn/utility/IgnoreUnused.hpp>
11 
12 namespace armnn
13 {
14 
15 ARMNN_NO_DEPRECATE_WARN_BEGIN
16 // IsLayerSupport() forwards to the deprecated virtual methods depending on input LayerType.
17 // Allows backends continue to behave as before maintaining backward compatibility.
18 bool ILayerSupport::IsLayerSupported(const LayerType& type,
19  const std::vector<TensorInfo>& infos,
20  const BaseDescriptor& descriptor,
21  const Optional<LstmInputParamsInfo>& lstmParamsInfo,
22  const Optional<QuantizedLstmInputParamsInfo>& quantizedLstmParamsInfo,
23  Optional<std::string&> reasonIfUnsupported) const
24 {
25  switch (type)
26  {
27  case LayerType::Activation:
28  return IsActivationSupported(infos[0],
29  infos[1],
30  *(PolymorphicDowncast<const ActivationDescriptor*>(&descriptor)),
31  reasonIfUnsupported);
32  case LayerType::Addition:
33  return IsAdditionSupported(infos[0],
34  infos[1],
35  infos[2],
36  reasonIfUnsupported);
37  case LayerType::ArgMinMax:
38  return IsArgMinMaxSupported(infos[0],
39  infos[1],
40  *(PolymorphicDowncast<const ArgMinMaxDescriptor*>(&descriptor)),
41  reasonIfUnsupported);
42  case LayerType::BatchNormalization:
43  return IsBatchNormalizationSupported(infos[0],
44  infos[1],
45  infos[2],
46  infos[3],
47  infos[4],
48  infos[5],
49  *(PolymorphicDowncast<const BatchNormalizationDescriptor*>
50  (&descriptor)),
51  reasonIfUnsupported);
52  case LayerType::BatchToSpaceNd:
53  return IsBatchToSpaceNdSupported(infos[0],
54  infos[1],
55  *(PolymorphicDowncast<const BatchToSpaceNdDescriptor*>(&descriptor)),
56  reasonIfUnsupported);
57  case LayerType::Comparison:
58  {
59  return IsComparisonSupported(infos[0],
60  infos[1],
61  infos[2],
62  *(PolymorphicDowncast<const ComparisonDescriptor*>(&descriptor)),
63  reasonIfUnsupported);
64  }
65  case LayerType::Concat:
66  {
67  std::vector<const TensorInfo*> inputInfos;
68  for (uint32_t i = 0; i < (infos.size() - 1); i++)
69  {
70  inputInfos.push_back(&infos[i]);
71  }
72  return IsConcatSupported(inputInfos,
73  infos[infos.size() - 1],
74  *(PolymorphicDowncast<const OriginsDescriptor*>(&descriptor)),
75  reasonIfUnsupported);
76  }
77  case LayerType::Constant:
78  return IsConstantSupported(infos[0],
79  reasonIfUnsupported);
80  case LayerType::ConvertBf16ToFp32:
81  return IsConvertBf16ToFp32Supported(infos[0],
82  infos[1],
83  reasonIfUnsupported);
84  case LayerType::ConvertFp16ToFp32:
85  return IsConvertFp16ToFp32Supported(infos[0],
86  infos[1],
87  reasonIfUnsupported);
88  case LayerType::ConvertFp32ToBf16:
89  return IsConvertFp32ToBf16Supported(infos[0],
90  infos[1],
91  reasonIfUnsupported);
92  case LayerType::ConvertFp32ToFp16:
93  return IsConvertFp32ToFp16Supported(infos[0],
94  infos[1],
95  reasonIfUnsupported);
96  case LayerType::Convolution2d:
97  {
98  if (infos.size() != 4)
99  {
100  throw InvalidArgumentException("Invalid number of Convolution2d "
101  "TensorInfos. TensorInfos should be of format: "
102  "{input, output, weights, biases}.");
103  }
104 
105  auto desc = *(PolymorphicDowncast<const Convolution2dDescriptor*>(&descriptor));
106  if (infos[3] == TensorInfo())
107  {
108  return IsConvolution2dSupported(infos[0],
109  infos[1],
110  desc,
111  infos[2],
112  EmptyOptional(),
113  reasonIfUnsupported);
114  }
115  else
116  {
117  return IsConvolution2dSupported(infos[0],
118  infos[1],
119  desc,
120  infos[2],
121  infos[3],
122  reasonIfUnsupported);
123  }
124  }
125  case LayerType::Debug:
126  return IsDebugSupported(infos[0],
127  infos[1],
128  reasonIfUnsupported);
129  case LayerType::DepthToSpace:
130  return IsDepthToSpaceSupported(infos[0],
131  infos[1],
132  *(PolymorphicDowncast<const DepthToSpaceDescriptor*>(&descriptor)),
133  reasonIfUnsupported);
134  case LayerType::DepthwiseConvolution2d:
135  {
136  if (infos.size() != 4)
137  {
138  throw InvalidArgumentException("Invalid number of DepthwiseConvolution2d "
139  "TensorInfos. TensorInfos should be of format: "
140  "{input, output, weights, biases}.");
141  }
142 
143  auto desc = *(PolymorphicDowncast<const DepthwiseConvolution2dDescriptor*>(&descriptor));
144  if (infos[3] == TensorInfo())
145  {
146  return IsDepthwiseConvolutionSupported(infos[0],
147  infos[1],
148  desc,
149  infos[2],
150  EmptyOptional(),
151  reasonIfUnsupported);
152  }
153  else
154  {
155  return IsDepthwiseConvolutionSupported(infos[0],
156  infos[1],
157  desc,
158  infos[2],
159  infos[3],
160  reasonIfUnsupported);
161  }
162  }
163  case LayerType::Dequantize:
164  return IsDequantizeSupported(infos[0],
165  infos[1],
166  reasonIfUnsupported);
167  case LayerType::DetectionPostProcess:
168  return IsDetectionPostProcessSupported(infos[0],
169  infos[1],
170  infos[2],
171  infos[3],
172  infos[4],
173  infos[5],
174  infos[6],
175  *(PolymorphicDowncast<const DetectionPostProcessDescriptor*>
176  (&descriptor)),
177  reasonIfUnsupported);
178  case LayerType::Division:
179  return IsDivisionSupported(infos[0],
180  infos[1],
181  infos[2],
182  reasonIfUnsupported);
183  case LayerType::ElementwiseUnary:
184  return IsElementwiseUnarySupported(infos[0],
185  infos[1],
186  *(PolymorphicDowncast<const ElementwiseUnaryDescriptor*>
187  (&descriptor)),
188  reasonIfUnsupported);
189  case LayerType::FakeQuantization:
190  return IsFakeQuantizationSupported(infos[0],
191  *(PolymorphicDowncast<const FakeQuantizationDescriptor*>
192  (&descriptor)),
193  reasonIfUnsupported);
194  case LayerType::Fill:
195  return IsFillSupported(infos[0],
196  infos[1],
197  *(PolymorphicDowncast<const FillDescriptor*>(&descriptor)),
198  reasonIfUnsupported);
199  case LayerType::Floor:
200  return IsFloorSupported(infos[0], infos[1], reasonIfUnsupported);
201  case LayerType::FullyConnected:
202  return IsFullyConnectedSupported(infos[0],
203  infos[1],
204  infos[2],
205  infos[3],
206  *(PolymorphicDowncast<const FullyConnectedDescriptor*>(&descriptor)),
207  reasonIfUnsupported);
208  case LayerType::Gather:
209  return IsGatherSupported(infos[0],
210  infos[1],
211  infos[2],
212  *(PolymorphicDowncast<const GatherDescriptor*>(&descriptor)),
213  reasonIfUnsupported);
214  case LayerType::Input:
215  return IsInputSupported(infos[0], reasonIfUnsupported);
216  case LayerType::InstanceNormalization:
217  return IsInstanceNormalizationSupported(infos[0],
218  infos[1],
219  *(PolymorphicDowncast<const InstanceNormalizationDescriptor*>
220  (&descriptor)),
221  reasonIfUnsupported);
222  case LayerType::L2Normalization:
223  return IsL2NormalizationSupported(infos[0],
224  infos[1],
225  *(PolymorphicDowncast<const L2NormalizationDescriptor*>
226  (&descriptor)),
227  reasonIfUnsupported);
228  case LayerType::LogicalBinary:
229  return IsLogicalBinarySupported(infos[0],
230  infos[1],
231  infos[2],
232  *(PolymorphicDowncast<const LogicalBinaryDescriptor*>(&descriptor)),
233  reasonIfUnsupported);
234  case LayerType::LogSoftmax:
235  return IsLogSoftmaxSupported(infos[0],
236  infos[1],
237  *(PolymorphicDowncast<const LogSoftmaxDescriptor*>(&descriptor)),
238  reasonIfUnsupported);
239  case LayerType::Lstm:
240  return IsLstmSupported(infos[0],
241  infos[1],
242  infos[2],
243  infos[3],
244  infos[4],
245  infos[5],
246  infos[6],
247  *(PolymorphicDowncast<const LstmDescriptor*>(&descriptor)),
248  lstmParamsInfo.value(),
249  reasonIfUnsupported);
250  case LayerType::QLstm:
251  return IsQLstmSupported(infos[0],
252  infos[1],
253  infos[2],
254  infos[3],
255  infos[4],
256  infos[5],
257  *(PolymorphicDowncast<const QLstmDescriptor*>(&descriptor)),
258  lstmParamsInfo.value(),
259  reasonIfUnsupported);
260  case LayerType::Map:
261  return true;
262  case LayerType::Maximum:
263  return IsMaximumSupported(infos[0],
264  infos[1],
265  infos[2],
266  reasonIfUnsupported);
267  case LayerType::Mean:
268  return IsMeanSupported(infos[0],
269  infos[1],
270  *(PolymorphicDowncast<const MeanDescriptor*>(&descriptor)),
271  reasonIfUnsupported);
272  case LayerType::MemCopy:
273  return IsMemCopySupported(std::move(infos[0]),
274  std::move(infos[1]),
275  reasonIfUnsupported);
276  case LayerType::MemImport:
277  return IsMemImportSupported(infos[0],
278  infos[1],
279  reasonIfUnsupported);
280  case LayerType::Merge:
281  return IsMergeSupported(infos[0],
282  infos[1],
283  infos[2],
284  reasonIfUnsupported);
285  case LayerType::Minimum:
286  return IsMinimumSupported(infos[0],
287  infos[1],
288  infos[2],
289  reasonIfUnsupported);
290  case LayerType::Multiplication:
291  return IsMultiplicationSupported(infos[0],
292  infos[1],
293  infos[2],
294  reasonIfUnsupported);
295  case LayerType::Normalization:
296  return IsNormalizationSupported(infos[0],
297  infos[1],
298  *(PolymorphicDowncast<const NormalizationDescriptor*>(&descriptor)),
299  reasonIfUnsupported);
300  case LayerType::Output:
301  return IsOutputSupported(infos[0], reasonIfUnsupported);
302  case LayerType::Pad:
303  return IsPadSupported(infos[0],
304  infos[1],
305  *(PolymorphicDowncast<const PadDescriptor*>(&descriptor)),
306  reasonIfUnsupported);
307  case LayerType::Permute:
308  return IsPermuteSupported(infos[0],
309  infos[1],
310  *(PolymorphicDowncast<const PermuteDescriptor*>(&descriptor)),
311  reasonIfUnsupported);
312  case LayerType::Pooling2d:
313  return IsPooling2dSupported(infos[0],
314  infos[1],
315  *(PolymorphicDowncast<const Pooling2dDescriptor*>(&descriptor)),
316  reasonIfUnsupported);
317  case LayerType::PreCompiled:
318  return IsPreCompiledSupported(infos[0],
319  *(PolymorphicDowncast<const PreCompiledDescriptor*>(&descriptor)),
320  reasonIfUnsupported);
321  case LayerType::Prelu:
322  return IsPreluSupported(infos[0],
323  infos[1],
324  infos[2],
325  reasonIfUnsupported);
326  case LayerType::Quantize:
327  return IsQuantizeSupported(infos[0],
328  infos[1],
329  reasonIfUnsupported);
330  case LayerType::QuantizedLstm:
331  return IsQuantizedLstmSupported(infos[0],
332  infos[1],
333  infos[2],
334  infos[3],
335  infos[4],
336  quantizedLstmParamsInfo.value(),
337  reasonIfUnsupported);
338  case LayerType::Reshape:
339  return IsReshapeSupported(infos[0],
340  infos[1],
341  *(PolymorphicDowncast<const ReshapeDescriptor*>(&descriptor)),
342  reasonIfUnsupported);
343  case LayerType::Rank:
344  return IsRankSupported(infos[0], infos[1], reasonIfUnsupported);
345  case LayerType::Resize:
346  return IsResizeSupported(infos[0],
347  infos[1],
348  *(PolymorphicDowncast<const ResizeDescriptor*>(&descriptor)),
349  reasonIfUnsupported);
350  case LayerType::Reduce:
351  return IsReduceSupported(infos[0],
352  infos[1],
353  *(PolymorphicDowncast<const ReduceDescriptor*>(&descriptor)),
354  reasonIfUnsupported);
355  case LayerType::Slice:
356  return IsSliceSupported(infos[0],
357  infos[1],
358  *(PolymorphicDowncast<const SliceDescriptor*>(&descriptor)),
359  reasonIfUnsupported);
360  case LayerType::Softmax:
361  return IsSoftmaxSupported(infos[0],
362  infos[1],
363  *(PolymorphicDowncast<const SoftmaxDescriptor*>(&descriptor)),
364  reasonIfUnsupported);
365  case LayerType::SpaceToBatchNd:
366  return IsSpaceToBatchNdSupported(infos[0],
367  infos[1],
368  *(PolymorphicDowncast<const SpaceToBatchNdDescriptor*>(&descriptor)),
369  reasonIfUnsupported);
370  case LayerType::SpaceToDepth:
371  return IsSpaceToDepthSupported(infos[0],
372  infos[1],
373  *(PolymorphicDowncast<const SpaceToDepthDescriptor*>(&descriptor)),
374  reasonIfUnsupported);
375  case LayerType::Splitter:
376  {
377  std::vector<TensorInfo> outputInfos;
378  for (uint32_t i = 1; i < infos.size(); i++)
379  {
380  outputInfos.push_back(infos[i]);
381  }
382  return IsSplitterSupported(infos[0],
383  {outputInfos.begin(), outputInfos.end()},
384  *(PolymorphicDowncast<const ViewsDescriptor*>(&descriptor)),
385  reasonIfUnsupported);
386  }
387  case LayerType::Stack:
388  {
389  std::vector<const TensorInfo*> inputInfos;
390  for (uint32_t i = 0; i < infos.size() - 1; i++)
391  {
392  inputInfos.push_back(&infos[i]);
393  }
394  return IsStackSupported(inputInfos,
395  infos[infos.size() - 1],
396  *(PolymorphicDowncast<const StackDescriptor*>(&descriptor)),
397  reasonIfUnsupported);
398  }
399  case LayerType::StandIn:
400  {
401  auto desc = *(PolymorphicDowncast<const StandInDescriptor*>(&descriptor));
402 
403  if (infos.size() != (desc.m_NumInputs + desc.m_NumOutputs))
404  {
405  throw InvalidArgumentException("Number of StandIn layer TensorInfos does not equal "
406  "the combined number of input and output slots assigned "
407  "to the StandIn descriptor");
408  }
409 
410  std::vector<const TensorInfo*> inputInfos;
411  for (uint32_t i = 0; i < desc.m_NumInputs; i++)
412  {
413  inputInfos.push_back(&infos[i]);
414  }
415  std::vector<const TensorInfo*> outputInfos;
416  for (uint32_t i = desc.m_NumInputs; i < infos.size(); i++)
417  {
418  outputInfos.push_back(&infos[i]);
419  }
420 
421  return IsStandInSupported(inputInfos,
422  outputInfos,
423  desc,
424  reasonIfUnsupported);
425  }
426  case LayerType::StridedSlice:
427  return IsStridedSliceSupported(infos[0],
428  infos[1],
429  *(PolymorphicDowncast<const StridedSliceDescriptor*>(&descriptor)),
430  reasonIfUnsupported);
431  case LayerType::Subtraction:
432  return IsSubtractionSupported(infos[0],
433  infos[1],
434  infos[2],
435  reasonIfUnsupported);
436  case LayerType::Switch:
437  return IsSwitchSupported(infos[0],
438  infos[1],
439  infos[2],
440  infos[3],
441  reasonIfUnsupported);
442  case LayerType::Transpose:
443  return IsTransposeSupported(infos[0],
444  infos[1],
445  *(PolymorphicDowncast<const TransposeDescriptor*>(&descriptor)),
446  reasonIfUnsupported);
447  case LayerType::TransposeConvolution2d:
448  {
449  if (infos.size() != 4)
450  {
451  throw InvalidArgumentException("Invalid number of TransposeConvolution2d "
452  "TensorInfos. TensorInfos should be of format: "
453  "{input, output, weights, biases}.");
454  }
455 
456  auto desc = *(PolymorphicDowncast<const TransposeConvolution2dDescriptor*>(&descriptor));
457  if (infos[3] == TensorInfo())
458  {
459  return IsTransposeConvolution2dSupported(infos[0],
460  infos[1],
461  desc,
462  infos[2],
463  EmptyOptional(),
464  reasonIfUnsupported);
465  }
466  else
467  {
468  return IsTransposeConvolution2dSupported(infos[0],
469  infos[1],
470  desc,
471  infos[2],
472  infos[3],
473  reasonIfUnsupported);
474  }
475  }
476  case LayerType::Unmap:
477  return true;
478  case LayerType::Cast:
479  return IsCastSupported(infos[0], infos[1], reasonIfUnsupported);
480  case LayerType::Shape:
481  return IsShapeSupported(infos[0], infos[1], reasonIfUnsupported);
482  case LayerType::UnidirectionalSequenceLstm:
483  {
484  if (infos.size() != 6)
485  {
486  throw InvalidArgumentException("Invalid number of TransposeConvolution2d TensorInfos. TensorInfos "
487  "should be of format: {input, outputStateIn, cellStateIn, "
488  "hiddenStateOutputVal, cellStateOutputVal, output}");
489  }
490  auto desc = *(PolymorphicDowncast<const UnidirectionalSequenceLstmDescriptor*>(&descriptor));
491 
492  bool isHiddenStateOutputOptional = (infos[4] == TensorInfo());
493  bool isCellStateOutput = (infos[5] == TensorInfo());
494  if (isHiddenStateOutputOptional && isCellStateOutput)
495  {
496  return IsUnidirectionalSequenceLstmSupported(infos[0],
497  infos[1],
498  infos[2],
499  infos[3],
500  EmptyOptional(),
501  EmptyOptional(),
502  desc,
503  lstmParamsInfo.value(),
504  reasonIfUnsupported);
505  }
506  else if (isHiddenStateOutputOptional)
507  {
508  return IsUnidirectionalSequenceLstmSupported(infos[0],
509  infos[1],
510  infos[2],
511  infos[3],
512  EmptyOptional(),
513  infos[5],
514  desc,
515  lstmParamsInfo.value(),
516  reasonIfUnsupported);
517  }
518  else if (isCellStateOutput)
519  {
520  return IsUnidirectionalSequenceLstmSupported(infos[0],
521  infos[1],
522  infos[2],
523  infos[3],
524  infos[4],
525  EmptyOptional(),
526  desc,
527  lstmParamsInfo.value(),
528  reasonIfUnsupported);
529  }
530  else
531  {
532  return IsUnidirectionalSequenceLstmSupported(infos[0],
533  infos[1],
534  infos[2],
535  infos[3],
536  infos[4],
537  infos[5],
538  desc,
539  lstmParamsInfo.value(),
540  reasonIfUnsupported);
541  }
542  }
543  case LayerType::ChannelShuffle:
544  return IsChannelShuffleSupported(infos[0],
545  infos[1],
546  *(PolymorphicDowncast<const ChannelShuffleDescriptor*>(&descriptor)),
547  reasonIfUnsupported);
548  case LayerType::Convolution3d:
549  {
550  if (infos.size() != 4)
551  {
552  throw InvalidArgumentException("Invalid number of Convolution3d "
553  "TensorInfos. TensorInfos should be of format: "
554  "{input, output, weights, biases}.");
555  }
556 
557  auto desc = *(PolymorphicDowncast<const Convolution3dDescriptor*>(&descriptor));
558  if (infos[3] == TensorInfo())
559  {
560  return IsConvolution3dSupported(infos[0],
561  infos[1],
562  desc,
563  infos[2],
564  EmptyOptional(),
565  reasonIfUnsupported);
566  }
567  else
568  {
569  return IsConvolution3dSupported(infos[0],
570  infos[1],
571  desc,
572  infos[2],
573  infos[3],
574  reasonIfUnsupported);
575  }
576  }
577  case LayerType::Pooling3d:
578  return IsPooling3dSupported(infos[0],
579  infos[1],
580  *(PolymorphicDowncast<const Pooling3dDescriptor*>(&descriptor)),
581  reasonIfUnsupported);
582  default:
583  return false;
584  }
585 }
586 
587 bool ILayerSupport::IsActivationSupported(const TensorInfo& input,
588  const TensorInfo& output,
589  const ActivationDescriptor& descriptor,
590  Optional<std::string&> reasonIfUnsupported) const
591 {
592  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
593  return false;
594 }
595 
596 bool ILayerSupport::IsAdditionSupported(const TensorInfo& input0,
597  const TensorInfo& input1,
598  const TensorInfo& output,
599  Optional<std::string&> reasonIfUnsupported) const
600 {
601  IgnoreUnused(input0, input1, output, reasonIfUnsupported);
602  return false;
603 }
604 
605 bool ILayerSupport::IsArgMinMaxSupported(const TensorInfo& input,
606  const TensorInfo& output,
607  const ArgMinMaxDescriptor& descriptor,
608  Optional<std::string&> reasonIfUnsupported) const
609 {
610  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
611  return false;
612 }
613 
614 bool ILayerSupport::IsBatchNormalizationSupported(const TensorInfo& input,
615  const TensorInfo& output,
616  const TensorInfo& mean,
617  const TensorInfo& var,
618  const TensorInfo& beta,
619  const TensorInfo& gamma,
620  const BatchNormalizationDescriptor& descriptor,
621  Optional<std::string&> reasonIfUnsupported) const
622 {
623  IgnoreUnused(input, output, mean, var, beta, gamma, descriptor, reasonIfUnsupported);
624  return false;
625 }
626 
627 bool ILayerSupport::IsBatchToSpaceNdSupported(const TensorInfo& input,
628  const TensorInfo& output,
629  const BatchToSpaceNdDescriptor& descriptor,
630  Optional<std::string&> reasonIfUnsupported) const
631 {
632  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
633  return false;
634 }
635 
636 bool ILayerSupport::IsCastSupported(const TensorInfo& input,
637  const TensorInfo& output,
638  Optional<std::string&> reasonIfUnsupported) const
639 {
640  IgnoreUnused(input, output, reasonIfUnsupported);
641  return false;
642 }
643 
644 bool ILayerSupport::IsChannelShuffleSupported(const TensorInfo& input,
645  const TensorInfo& output,
646  const ChannelShuffleDescriptor& descriptor,
647  Optional<std::string&> reasonIfUnsupported) const
648 {
649  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
650  return false;
651 }
652 
653 bool ILayerSupport::IsComparisonSupported(const TensorInfo& input0,
654  const TensorInfo& input1,
655  const TensorInfo& output,
656  const ComparisonDescriptor& descriptor,
657  Optional<std::string&> reasonIfUnsupported) const
658 {
659  IgnoreUnused(input0, input1, output, descriptor, reasonIfUnsupported);
660  return false;
661 }
662 
663 bool ILayerSupport::IsConcatSupported(const std::vector<const TensorInfo*> inputs,
664  const TensorInfo& output,
665  const OriginsDescriptor& descriptor,
666  Optional<std::string&> reasonIfUnsupported) const
667 {
668  IgnoreUnused(inputs, output, descriptor, reasonIfUnsupported);
669  return false;
670 }
671 
672 bool ILayerSupport::IsConstantSupported(const TensorInfo& output,
673  Optional<std::string&> reasonIfUnsupported) const
674 {
675  IgnoreUnused(output, reasonIfUnsupported);
676  return false;
677 }
678 
679 bool ILayerSupport::IsConvertBf16ToFp32Supported(const TensorInfo& input,
680  const TensorInfo& output,
681  Optional<std::string&> reasonIfUnsupported) const
682 {
683  IgnoreUnused(input, output, reasonIfUnsupported);
684  return false;
685 }
686 
687 bool ILayerSupport::IsConvertFp32ToBf16Supported(const TensorInfo& input,
688  const TensorInfo& output,
689  Optional<std::string&> reasonIfUnsupported) const
690 {
691  IgnoreUnused(input, output, reasonIfUnsupported);
692  return false;
693 }
694 
695 bool ILayerSupport::IsConvertFp16ToFp32Supported(const TensorInfo& input,
696  const TensorInfo& output,
697  Optional<std::string&> reasonIfUnsupported) const
698 {
699  IgnoreUnused(input, output, reasonIfUnsupported);
700  return false;
701 }
702 
703 bool ILayerSupport::IsConvertFp32ToFp16Supported(const TensorInfo& input,
704  const TensorInfo& output,
705  Optional<std::string&> reasonIfUnsupported) const
706 {
707  IgnoreUnused(input, output, reasonIfUnsupported);
708  return false;
709 }
710 
711 bool ILayerSupport::IsConvolution2dSupported(const TensorInfo& input,
712  const TensorInfo& output,
713  const Convolution2dDescriptor& descriptor,
714  const TensorInfo& weights,
715  const Optional<TensorInfo>& biases,
716  Optional<std::string&> reasonIfUnsupported) const
717 {
718  IgnoreUnused(input, output, descriptor, weights, biases, reasonIfUnsupported);
719  return false;
720 }
721 
722 bool ILayerSupport::IsConvolution3dSupported(const TensorInfo& input,
723  const TensorInfo& output,
724  const Convolution3dDescriptor& descriptor,
725  const TensorInfo& weights,
726  const Optional<TensorInfo>& biases,
727  Optional<std::string&> reasonIfUnsupported) const
728 {
729  IgnoreUnused(input, output, descriptor, weights, biases, reasonIfUnsupported);
730  return false;
731 }
732 
733 bool ILayerSupport::IsDebugSupported(const TensorInfo& input,
734  const TensorInfo& output,
735  Optional<std::string&> reasonIfUnsupported) const
736 {
737  IgnoreUnused(input, output, reasonIfUnsupported);
738  return false;
739 }
740 
741 bool ILayerSupport::IsDepthToSpaceSupported(const TensorInfo& input,
742  const TensorInfo& output,
743  const DepthToSpaceDescriptor& descriptor,
744  Optional<std::string&> reasonIfUnsupported) const
745 {
746  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
747  return false;
748 }
749 
750 bool ILayerSupport::IsDepthwiseConvolutionSupported(
751  const TensorInfo& input,
752  const TensorInfo& output,
753  const DepthwiseConvolution2dDescriptor& descriptor,
754  const TensorInfo& weights,
755  const Optional<TensorInfo>& biases,
756  Optional<std::string&> reasonIfUnsupported) const
757 {
758  IgnoreUnused(input,
759  output,
760  descriptor,
761  weights,
762  biases,
763  reasonIfUnsupported);
764  return false;
765 }
766 
767 bool ILayerSupport::IsDequantizeSupported(const TensorInfo& input,
768  const TensorInfo& output,
769  Optional<std::string&> reasonIfUnsupported) const
770 {
771  IgnoreUnused(input, output, reasonIfUnsupported);
772  return false;
773 }
774 
775 bool ILayerSupport::IsDetectionPostProcessSupported(const TensorInfo& boxEncodings,
776  const TensorInfo& scores,
777  const TensorInfo& anchors,
778  const TensorInfo& detectionBoxes,
779  const TensorInfo& detectionClasses,
780  const TensorInfo& detectionScores,
781  const TensorInfo& numDetections,
782  const DetectionPostProcessDescriptor& descriptor,
783  Optional<std::string&> reasonIfUnsupported) const
784 {
785  IgnoreUnused(boxEncodings,
786  scores,
787  anchors,
788  detectionBoxes,
789  detectionClasses,
790  detectionScores,
791  numDetections,
792  descriptor,
793  reasonIfUnsupported);
794  return false;
795 }
796 
797 bool ILayerSupport::IsDilatedDepthwiseConvolutionSupported(
798  const TensorInfo& input,
799  const TensorInfo& output,
800  const DepthwiseConvolution2dDescriptor& descriptor,
801  const TensorInfo& weights,
802  const Optional<TensorInfo>& biases,
803  Optional<std::string&> reasonIfUnsupported) const
804 {
805  IgnoreUnused(input, output, descriptor, weights, biases, reasonIfUnsupported);
806  return false;
807 }
808 
809 bool ILayerSupport::IsDivisionSupported(const TensorInfo& input0,
810  const TensorInfo& input1,
811  const TensorInfo& output,
812  Optional<std::string&> reasonIfUnsupported) const
813 {
814  IgnoreUnused(input0, input1, output, reasonIfUnsupported);
815  return false;
816 }
817 
818 bool ILayerSupport::IsElementwiseUnarySupported(const TensorInfo& input,
819  const TensorInfo& output,
820  const ElementwiseUnaryDescriptor& descriptor,
821  Optional<std::string&> reasonIfUnsupported) const
822 {
823  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
824  return false;
825 }
826 
827 bool ILayerSupport::IsFakeQuantizationSupported(const TensorInfo& input,
828  const FakeQuantizationDescriptor& descriptor,
829  Optional<std::string&> reasonIfUnsupported) const
830 {
831  IgnoreUnused(input, descriptor, reasonIfUnsupported);
832  return false;
833 }
834 
835 bool ILayerSupport::IsFillSupported(const TensorInfo& input,
836  const TensorInfo& output,
837  const FillDescriptor& descriptor,
838  Optional<std::string&> reasonIfUnsupported) const
839 {
840  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
841  return false;
842 }
843 
844 bool ILayerSupport::IsFloorSupported(const TensorInfo& input,
845  const TensorInfo& output,
846  Optional<std::string&> reasonIfUnsupported) const
847 {
848  IgnoreUnused(input, output, reasonIfUnsupported);
849  return false;
850 }
851 
852 bool ILayerSupport::IsFullyConnectedSupported(const TensorInfo& input,
853  const TensorInfo& output,
854  const TensorInfo& weights,
855  const TensorInfo& biases,
856  const FullyConnectedDescriptor& descriptor,
857  Optional<std::string&> reasonIfUnsupported) const
858 {
859  IgnoreUnused(input, output, weights, biases, descriptor, reasonIfUnsupported);
860  return false;
861 }
862 
863 bool ILayerSupport::IsGatherSupported(const TensorInfo& input0,
864  const TensorInfo& input1,
865  const TensorInfo& output,
866  const GatherDescriptor& descriptor,
867  Optional<std::string&> reasonIfUnsupported) const
868 {
869  IgnoreUnused(input0, input1, output, descriptor, reasonIfUnsupported);
870  return false;
871 }
872 
873 bool ILayerSupport::IsInputSupported(const TensorInfo& input,
874  Optional<std::string&> reasonIfUnsupported) const
875 {
876  IgnoreUnused(input, reasonIfUnsupported);
877  return false;
878 }
879 
880 bool ILayerSupport::IsInstanceNormalizationSupported(
881  const TensorInfo& input,
882  const TensorInfo& output,
883  const InstanceNormalizationDescriptor& descriptor,
884  Optional<std::string&> reasonIfUnsupported) const
885 {
886  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
887  return false;
888 }
889 
890 bool ILayerSupport::IsL2NormalizationSupported(const TensorInfo& input,
891  const TensorInfo& output,
892  const L2NormalizationDescriptor& descriptor,
893  Optional<std::string&> reasonIfUnsupported) const
894 {
895  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
896  return false;
897 }
898 
899 bool ILayerSupport::IsLogicalBinarySupported(const TensorInfo& input0,
900  const TensorInfo& input1,
901  const TensorInfo& output,
902  const LogicalBinaryDescriptor& descriptor,
903  Optional<std::string&> reasonIfUnsupported) const
904 {
905  IgnoreUnused(input0, input1, output, descriptor, reasonIfUnsupported);
906  return false;
907 }
908 
909 bool ILayerSupport::IsLogicalUnarySupported(const TensorInfo& input,
910  const TensorInfo& output,
911  const ElementwiseUnaryDescriptor& descriptor,
912  Optional<std::string&> reasonIfUnsupported) const
913 {
914  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
915  return false;
916 }
917 
918 bool ILayerSupport::IsLogSoftmaxSupported(const TensorInfo& input,
919  const TensorInfo& output,
920  const LogSoftmaxDescriptor& descriptor,
921  Optional<std::string&> reasonIfUnsupported) const
922 {
923  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
924  return false;
925 }
926 
927 bool ILayerSupport::IsLstmSupported(const TensorInfo& input,
928  const TensorInfo& outputStateIn,
929  const TensorInfo& cellStateIn,
930  const TensorInfo& scratchBuffer,
931  const TensorInfo& outputStateOut,
932  const TensorInfo& cellStateOut,
933  const TensorInfo& output,
934  const LstmDescriptor& descriptor,
935  const LstmInputParamsInfo& paramsInfo,
936  Optional<std::string&> reasonIfUnsupported) const
937 {
938  IgnoreUnused(input,
939  outputStateIn,
940  cellStateIn,
941  scratchBuffer,
942  outputStateOut,
943  cellStateOut,
944  output,
945  descriptor,
946  paramsInfo,
947  reasonIfUnsupported);
948  return false;
949 }
950 
951 bool ILayerSupport::IsMaximumSupported(const TensorInfo& input0,
952  const TensorInfo& input1,
953  const TensorInfo& output,
954  Optional<std::string&> reasonIfUnsupported) const
955 {
956  IgnoreUnused(input0, input1, output, reasonIfUnsupported);
957  return false;
958 }
959 
960 bool ILayerSupport::IsMeanSupported(const TensorInfo& input,
961  const TensorInfo& output,
962  const MeanDescriptor& descriptor,
963  Optional<std::string&> reasonIfUnsupported) const
964 {
965  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
966  return false;
967 }
968 
969 bool ILayerSupport::IsMemCopySupported(const TensorInfo& input,
970  const TensorInfo& output,
971  Optional<std::string&> reasonIfUnsupported) const
972 {
973  IgnoreUnused(input, output, reasonIfUnsupported);
974  return false;
975 }
976 
977 bool ILayerSupport::IsMemImportSupported(const TensorInfo& input,
978  const TensorInfo& output,
979  Optional<std::string&> reasonIfUnsupported) const
980 {
981  IgnoreUnused(input, output, reasonIfUnsupported);
982  return false;
983 }
984 
985 bool ILayerSupport::IsMergeSupported(const TensorInfo& input0,
986  const TensorInfo& input1,
987  const TensorInfo& output,
988  Optional<std::string&> reasonIfUnsupported) const
989 {
990  IgnoreUnused(input0, input1, output, reasonIfUnsupported);
991  return false;
992 }
993 
994 bool ILayerSupport::IsMinimumSupported(const TensorInfo& input0,
995  const TensorInfo& input1,
996  const TensorInfo& output,
997  Optional<std::string&> reasonIfUnsupported) const
998 {
999  IgnoreUnused(input0, input1, output, reasonIfUnsupported);
1000  return false;
1001 }
1002 
1003 bool ILayerSupport::IsMultiplicationSupported(const TensorInfo& input0,
1004  const TensorInfo& input1,
1005  const TensorInfo& output,
1006  Optional<std::string&> reasonIfUnsupported) const
1007 {
1008  IgnoreUnused(input0, input1, output, reasonIfUnsupported);
1009  return false;
1010 }
1011 
1012 bool ILayerSupport::IsNormalizationSupported(const TensorInfo& input,
1013  const TensorInfo& output,
1014  const NormalizationDescriptor& descriptor,
1015  Optional<std::string&> reasonIfUnsupported) const
1016 {
1017  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
1018  return false;
1019 }
1020 
1021 bool ILayerSupport::IsOutputSupported(const TensorInfo& output,
1022  Optional<std::string&> reasonIfUnsupported) const
1023 {
1024  IgnoreUnused(output, reasonIfUnsupported);
1025  return false;
1026 }
1027 
1028 bool ILayerSupport::IsPadSupported(const TensorInfo& input,
1029  const TensorInfo& output,
1030  const PadDescriptor& descriptor,
1031  Optional<std::string&> reasonIfUnsupported) const
1032 {
1033  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
1034  return false;
1035 }
1036 
1037 bool ILayerSupport::IsPermuteSupported(const TensorInfo& input,
1038  const TensorInfo& output,
1039  const PermuteDescriptor& descriptor,
1040  Optional<std::string&> reasonIfUnsupported) const
1041 {
1042  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
1043  return false;
1044 }
1045 
1046 bool ILayerSupport::IsPooling2dSupported(const TensorInfo& input,
1047  const TensorInfo& output,
1048  const Pooling2dDescriptor& descriptor,
1049  Optional<std::string&> reasonIfUnsupported) const
1050 {
1051  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
1052  return false;
1053 }
1054 
1055 bool ILayerSupport::IsPooling3dSupported(const TensorInfo& input,
1056  const TensorInfo& output,
1057  const Pooling3dDescriptor& descriptor,
1058  Optional<std::string&> reasonIfUnsupported) const
1059 {
1060  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
1061  return false;
1062 }
1063 
1064 bool ILayerSupport::IsPreCompiledSupported(const TensorInfo& input,
1065  const PreCompiledDescriptor& descriptor,
1066  Optional<std::string&> reasonIfUnsupported) const
1067 {
1068  IgnoreUnused(input, descriptor, reasonIfUnsupported);
1069  return false;
1070 }
1071 
1072 bool ILayerSupport::IsPreluSupported(const TensorInfo& input,
1073  const TensorInfo& alpha,
1074  const TensorInfo& output,
1075  Optional<std::string&> reasonIfUnsupported) const
1076 {
1077  IgnoreUnused(input, alpha, output, reasonIfUnsupported);
1078  return false;
1079 }
1080 
1081 bool ILayerSupport::IsQuantizeSupported(const TensorInfo& input,
1082  const TensorInfo& output,
1083  Optional<std::string&> reasonIfUnsupported) const
1084 {
1085  IgnoreUnused(input, output, reasonIfUnsupported);
1086  return false;
1087 }
1088 
1089 bool ILayerSupport::IsQLstmSupported(const TensorInfo& input,
1090  const TensorInfo& previousOutputIn,
1091  const TensorInfo& previousCellStateIn,
1092  const TensorInfo& outputStateOut,
1093  const TensorInfo& cellStateOut,
1094  const TensorInfo& output,
1095  const QLstmDescriptor& descriptor,
1096  const LstmInputParamsInfo& paramsInfo,
1097  Optional<std::string&> reasonIfUnsupported) const
1098 {
1099  IgnoreUnused(input,
1100  previousOutputIn,
1101  previousCellStateIn,
1102  outputStateOut,
1103  cellStateOut,
1104  output,
1105  descriptor,
1106  paramsInfo,
1107  reasonIfUnsupported);
1108  return false;
1109 }
1110 
1111 bool ILayerSupport::IsQuantizedLstmSupported(const TensorInfo& input,
1112  const TensorInfo& previousCellStateIn,
1113  const TensorInfo& previousOutputIn,
1114  const TensorInfo& cellStateOut,
1115  const TensorInfo& output,
1116  const QuantizedLstmInputParamsInfo& paramsInfo,
1117  Optional<std::string&> reasonIfUnsupported) const
1118 {
1119  IgnoreUnused(input,
1120  previousCellStateIn,
1121  previousOutputIn,
1122  cellStateOut,
1123  output,
1124  paramsInfo,
1125  reasonIfUnsupported);
1126  return false;
1127 }
1128 
1129 bool ILayerSupport::IsRankSupported(const TensorInfo& input,
1130  const TensorInfo& output,
1131  Optional<std::string&> reasonIfUnsupported) const
1132 {
1133  IgnoreUnused(input, output, reasonIfUnsupported);
1134  return false;
1135 }
1136 
1137 bool ILayerSupport::IsReduceSupported(const TensorInfo& input,
1138  const TensorInfo& output,
1139  const ReduceDescriptor& descriptor,
1140  Optional<std::string&> reasonIfUnsupported) const
1141 {
1142  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
1143  return false;
1144 }
1145 
1146 bool ILayerSupport::IsReshapeSupported(const TensorInfo& input,
1147  const TensorInfo& output,
1148  const ReshapeDescriptor& descriptor,
1149  Optional<std::string&> reasonIfUnsupported) const
1150 {
1151  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
1152  return false;
1153 }
1154 
1155 bool ILayerSupport::IsResizeSupported(const TensorInfo& input,
1156  const TensorInfo& output,
1157  const ResizeDescriptor& descriptor,
1158  Optional<std::string&> reasonIfUnsupported) const
1159 {
1160  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
1161  return false;
1162 }
1163 
1164 bool ILayerSupport::IsShapeSupported(const TensorInfo& input,
1165  const TensorInfo& output,
1166  Optional<std::string&> reasonIfUnsupported) const
1167 {
1168  IgnoreUnused(input, output, reasonIfUnsupported);
1169  return false;
1170 }
1171 
1172 bool ILayerSupport::IsSliceSupported(const TensorInfo& input,
1173  const TensorInfo& output,
1174  const SliceDescriptor& descriptor,
1175  Optional<std::string&> reasonIfUnsupported) const
1176 {
1177  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
1178  return false;
1179 }
1180 
1181 bool ILayerSupport::IsSoftmaxSupported(const TensorInfo& input,
1182  const TensorInfo& output,
1183  const SoftmaxDescriptor& descriptor,
1184  Optional<std::string&> reasonIfUnsupported) const
1185 {
1186  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
1187  return false;
1188 }
1189 
1190 bool ILayerSupport::IsSpaceToBatchNdSupported(const TensorInfo& input,
1191  const TensorInfo& output,
1192  const SpaceToBatchNdDescriptor& descriptor,
1193  Optional<std::string&> reasonIfUnsupported) const
1194 {
1195  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
1196  return false;
1197 }
1198 
1199 bool ILayerSupport::IsSpaceToDepthSupported(const TensorInfo& input,
1200  const TensorInfo& output,
1201  const SpaceToDepthDescriptor& descriptor,
1202  Optional<std::string&> reasonIfUnsupported) const
1203 {
1204  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
1205  return false;
1206 }
1207 
1208 bool ILayerSupport::IsSplitterSupported(const TensorInfo& input,
1209  const std::vector<std::reference_wrapper<TensorInfo>>& outputs,
1210  const ViewsDescriptor& descriptor,
1211  Optional<std::string&> reasonIfUnsupported) const
1212 {
1213  IgnoreUnused(input, outputs, descriptor, reasonIfUnsupported);
1214  return false;
1215 }
1216 
1217 bool ILayerSupport::IsStackSupported(const std::vector<const TensorInfo*>& inputs,
1218  const TensorInfo& output,
1219  const StackDescriptor& descriptor,
1220  Optional<std::string&> reasonIfUnsupported) const
1221 {
1222  IgnoreUnused(inputs, output, descriptor, reasonIfUnsupported);
1223  return false;
1224 }
1225 
1226 bool ILayerSupport::IsStandInSupported(const std::vector<const TensorInfo*>& inputs,
1227  const std::vector<const TensorInfo*>& outputs,
1228  const StandInDescriptor& descriptor,
1229  Optional<std::string&> reasonIfUnsupported) const
1230 {
1231  IgnoreUnused(inputs, outputs, descriptor, reasonIfUnsupported);
1232  return false;
1233 }
1234 
1235 bool ILayerSupport::IsStridedSliceSupported(const TensorInfo& input,
1236  const TensorInfo& output,
1237  const StridedSliceDescriptor& descriptor,
1238  Optional<std::string&> reasonIfUnsupported) const
1239 {
1240  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
1241  return false;
1242 }
1243 
1244 bool ILayerSupport::IsSubtractionSupported(const TensorInfo& input0,
1245  const TensorInfo& input1,
1246  const TensorInfo& output,
1247  Optional<std::string&> reasonIfUnsupported) const
1248 {
1249  IgnoreUnused(input0, input1, output, reasonIfUnsupported);
1250  return false;
1251 }
1252 
1253 bool ILayerSupport::IsSwitchSupported(const TensorInfo& input0,
1254  const TensorInfo& input1,
1255  const TensorInfo& output0,
1256  const TensorInfo& output1,
1257  Optional<std::string&> reasonIfUnsupported) const
1258 {
1259  IgnoreUnused(input0, input1, output0, output1, reasonIfUnsupported);
1260  return false;
1261 }
1262 
1263 bool ILayerSupport::IsTransposeConvolution2dSupported(
1264  const TensorInfo& input,
1265  const TensorInfo& output,
1266  const TransposeConvolution2dDescriptor& descriptor,
1267  const TensorInfo& weights,
1268  const Optional<TensorInfo>& biases,
1269  Optional<std::string&> reasonIfUnsupported) const
1270 {
1271  IgnoreUnused(input, output, descriptor, weights, biases, reasonIfUnsupported);
1272  return false;
1273 }
1274 
1275 bool ILayerSupport::IsTransposeSupported(const TensorInfo& input,
1276  const TensorInfo& output,
1277  const TransposeDescriptor& descriptor,
1278  Optional<std::string&> reasonIfUnsupported) const
1279 {
1280  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
1281  return false;
1282 }
1283 
1284 bool ILayerSupport::IsUnidirectionalSequenceLstmSupported(
1285  const TensorInfo& input,
1286  const TensorInfo& outputStateIn,
1287  const TensorInfo& cellStateIn,
1288  const TensorInfo& output,
1289  const Optional<TensorInfo>& hiddenStateOutput,
1290  const Optional<TensorInfo>& cellStateOutput,
1291  const LstmDescriptor& descriptor,
1292  const LstmInputParamsInfo& paramsInfo,
1293  Optional<std::string&> reasonIfUnsupported) const
1294 {
1295  IgnoreUnused(input,
1296  outputStateIn,
1297  cellStateIn,
1298  output,
1299  hiddenStateOutput,
1300  cellStateOutput,
1301  descriptor,
1302  paramsInfo,
1303  reasonIfUnsupported);
1304  return false;
1305 }
1306 ARMNN_NO_DEPRECATE_WARN_END
1307 }
IgnoreUnused.hpp
armnn::ILayerSupport::hiddenStateOutput
const TensorInfo const TensorInfo const TensorInfo const Optional< TensorInfo > & hiddenStateOutput
Definition: ILayerSupport.hpp:561
armnn::IsMemCopySupported
bool IsMemCopySupported(const BackendId &backend, const TensorInfo &input, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::IsSoftmaxSupported
bool IsSoftmaxSupported(const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const SoftmaxDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::IsConcatSupported
bool IsConcatSupported(const BackendId &backend, const std::vector< const TensorInfo *> inputs, const TensorInfo &output, const OriginsDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::IsOutputSupported
bool IsOutputSupported(const BackendId &backend, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::ViewsDescriptor
A ViewsDescriptor for the SplitterLayer.
Definition: Descriptors.hpp:217
armnn::ILayerSupport::anchors
const TensorInfo const TensorInfo & anchors
Definition: ILayerSupport.hpp:184
armnn::IsQuantizedLstmSupported
bool IsQuantizedLstmSupported(const BackendId &backend, const TensorInfo &input, const TensorInfo &previousCellStateIn, const TensorInfo &previousOutputIn, const TensorInfo &cellStateOut, const TensorInfo &output, const QuantizedLstmInputParamsInfo &paramsInfo, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::IsSwitchSupported
bool IsSwitchSupported(const BackendId &backend, const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output0, const TensorInfo &output1, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::TransposeConvolution2dDescriptor
A TransposeConvolution2dDescriptor for the TransposeConvolution2dLayer.
Definition: Descriptors.hpp:1392
armnn::ILayerSupport::paramsInfo
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo const LstmDescriptor const LstmInputParamsInfo & paramsInfo
Definition: ILayerSupport.hpp:298
Tensor.hpp
armnn::ILayerSupport::cellStateOutput
const TensorInfo const TensorInfo const TensorInfo const Optional< TensorInfo > const Optional< TensorInfo > & cellStateOutput
Definition: ILayerSupport.hpp:561
armnn::ReshapeDescriptor
A ReshapeDescriptor for the ReshapeLayer.
Definition: Descriptors.hpp:999
armnn::IsLstmSupported
bool IsLstmSupported(const BackendId &backend, 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, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
ARMNN_NO_DEPRECATE_WARN_BEGIN
#define ARMNN_NO_DEPRECATE_WARN_BEGIN
Definition: Deprecated.hpp:33
armnn::ComparisonDescriptor
A ComparisonDescriptor for the ComparisonLayer.
Definition: Descriptors.hpp:89
armnn::IsBatchNormalizationSupported
bool IsBatchNormalizationSupported(const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const TensorInfo &mean, const TensorInfo &var, const TensorInfo &beta, const TensorInfo &gamma, const BatchNormalizationDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::ILayerSupport::gamma
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo & gamma
Definition: ILayerSupport.hpp:62
armnn::ILayerSupport::outputs
const std::vector< std::reference_wrapper< TensorInfo > > & outputs
Definition: ILayerSupport.hpp:500
armnn::IsDebugSupported
bool IsDebugSupported(const BackendId &backend, const TensorInfo &input, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::IsPreCompiledSupported
bool IsPreCompiledSupported(const BackendId &backend, const TensorInfo &input, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::Convolution2dDescriptor
A Convolution2dDescriptor for the Convolution2dLayer.
Definition: Descriptors.hpp:499
armnn::IsDequantizeSupported
bool IsDequantizeSupported(const BackendId &backend, const TensorInfo &input, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::ILayerSupport::IsLayerSupported
virtual bool IsLayerSupported(const LayerType &type, const std::vector< TensorInfo > &infos, const BaseDescriptor &descriptor, const Optional< LstmInputParamsInfo > &lstmParamsInfo=EmptyOptional(), const Optional< QuantizedLstmInputParamsInfo > &quantizedLstmParamsInfo=EmptyOptional(), Optional< std::string &> reasonIfUnsupported=EmptyOptional()) const
Definition: ILayerSupport.cpp:18
armnn::IsMaximumSupported
bool IsMaximumSupported(const BackendId &backend, const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, char *reasonIfUnSupported=nullptr, size_t reasonIfUnSupportedMaxLength=0)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::IsL2NormalizationSupported
bool IsL2NormalizationSupported(const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const L2NormalizationDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::IsStridedSliceSupported
bool IsStridedSliceSupported(const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const StridedSliceDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::ILayerSupport::reasonIfUnsupported
const TensorInfo const ActivationDescriptor Optional< std::string & > reasonIfUnsupported
Definition: ILayerSupport.hpp:43
armnn::IsTransposeConvolution2dSupported
bool IsTransposeConvolution2dSupported(const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const TransposeConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::IsDepthwiseConvolutionSupported
bool IsDepthwiseConvolutionSupported(const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const DepthwiseConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::ILayerSupport::outputStateOut
const TensorInfo const TensorInfo const TensorInfo const TensorInfo & outputStateOut
Definition: ILayerSupport.hpp:298
armnn::LogicalBinaryDescriptor
A LogicalBinaryDescriptor for the LogicalBinaryLayer.
Definition: Descriptors.hpp:1463
armnn::ILayerSupport::scores
const TensorInfo & scores
Definition: ILayerSupport.hpp:184
armnn::ILayerSupport::output0
const TensorInfo const TensorInfo & output0
Definition: ILayerSupport.hpp:535
armnn::ILayerSupport::detectionClasses
const TensorInfo const TensorInfo const TensorInfo const TensorInfo & detectionClasses
Definition: ILayerSupport.hpp:184
armnn::IsMergeSupported
bool IsMergeSupported(const BackendId &backend, const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn
Copyright (c) 2021 ARM Limited and Contributors.
Definition: 01_00_quick_start.dox:6
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::ILayerSupport::descriptor
const TensorInfo const ActivationDescriptor & descriptor
Definition: ILayerSupport.hpp:41
armnn::SpaceToDepthDescriptor
A SpaceToDepthDescriptor for the SpaceToDepthLayer.
Definition: Descriptors.hpp:1051
armnn::IsResizeSupported
bool IsResizeSupported(const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const ResizeDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::BatchToSpaceNdDescriptor
A BatchToSpaceNdDescriptor for the BatchToSpaceNdLayer.
Definition: Descriptors.hpp:835
armnn::IsSpaceToBatchNdSupported
bool IsSpaceToBatchNdSupported(const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const SpaceToBatchNdDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::ILayerSupport::outputStateIn
const TensorInfo & outputStateIn
Definition: ILayerSupport.hpp:298
armnn::ILayerSupport::previousCellStateIn
const TensorInfo const TensorInfo & previousCellStateIn
Definition: ILayerSupport.hpp:417
armnn::ILayerSupport::output1
const TensorInfo const TensorInfo const TensorInfo & output1
Definition: ILayerSupport.hpp:535
armnn::ILayerSupport::numDetections
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo & numDetections
Definition: ILayerSupport.hpp:184
armnn::ResizeDescriptor
A ResizeBilinearDescriptor for the ResizeBilinearLayer.
Definition: Descriptors.hpp:961
armnn::ILayerSupport::alpha
const TensorInfo & alpha
Definition: ILayerSupport.hpp:404
armnn::IsFakeQuantizationSupported
bool IsFakeQuantizationSupported(const BackendId &backend, const TensorInfo &input, const FakeQuantizationDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::BaseDescriptor
Base class for all descriptors.
Definition: Descriptors.hpp:22
armnn::StackDescriptor
A StackDescriptor for the StackLayer.
Definition: Descriptors.hpp:1203
armnn::IsSubtractionSupported
bool IsSubtractionSupported(const BackendId &backend, const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::IsFullyConnectedSupported
bool IsFullyConnectedSupported(const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const TensorInfo &weights, const TensorInfo &biases, const FullyConnectedDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
PolymorphicDowncast.hpp
armnn::PadDescriptor
A PadDescriptor for the PadLayer.
Definition: Descriptors.hpp:1148
armnn::ILayerSupport::cellStateIn
const TensorInfo const TensorInfo & cellStateIn
Definition: ILayerSupport.hpp:298
armnn::LstmDescriptor
An LstmDescriptor for the LstmLayer.
Definition: Descriptors.hpp:1078
ARMNN_NO_DEPRECATE_WARN_END
#define ARMNN_NO_DEPRECATE_WARN_END
Definition: Deprecated.hpp:34
armnn::L2NormalizationDescriptor
A L2NormalizationDescriptor for the L2NormalizationLayer.
Definition: Descriptors.hpp:769
armnn::ILayerSupport::var
const TensorInfo const TensorInfo const TensorInfo & var
Definition: ILayerSupport.hpp:62
armnn::ArgMinMaxDescriptor
An ArgMinMaxDescriptor for ArgMinMaxLayer.
Definition: Descriptors.hpp:67
armnn::OriginsDescriptor
An OriginsDescriptor for the ConcatLayer.
Definition: Descriptors.hpp:174
armnn::ReduceDescriptor
A ReduceDescriptor for the REDUCE operators.
Definition: Descriptors.hpp:1483
armnn::IsDivisionSupported
bool IsDivisionSupported(const BackendId &backend, const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
Types.hpp
armnn::FullyConnectedDescriptor
A FullyConnectedDescriptor for the FullyConnectedLayer.
Definition: Descriptors.hpp:468
armnn::IsStackSupported
bool IsStackSupported(const BackendId &backend, const std::vector< const TensorInfo *> inputs, const TensorInfo &output, const StackDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::FakeQuantizationDescriptor
A FakeQuantizationDescriptor for the FakeQuantizationLayer.
Definition: Descriptors.hpp:866
armnn::IsSpaceToDepthSupported
bool IsSpaceToDepthSupported(const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const SpaceToDepthDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::IsConvertFp32ToFp16Supported
bool IsConvertFp32ToFp16Supported(const BackendId &backend, const TensorInfo &input, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::GatherDescriptor
A GatherDescriptor for the GatherLayer.
Definition: Descriptors.hpp:904
ILayerSupport.hpp
armnn::ILayerSupport::beta
const TensorInfo const TensorInfo const TensorInfo const TensorInfo & beta
Definition: ILayerSupport.hpp:62
armnn::StandInDescriptor
A StandInDescriptor for the StandIn layer.
Definition: Descriptors.hpp:1233
armnn::QLstmDescriptor
A QLstmDescriptor for the QLstmLayer.
Definition: Descriptors.hpp:1332
armnn::IsMinimumSupported
bool IsMinimumSupported(const BackendId &backend, const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::ActivationDescriptor
An ActivationDescriptor for the ActivationLayer.
Definition: Descriptors.hpp:36
armnn::SliceDescriptor
A SliceDescriptor for the SliceLayer.
Definition: Descriptors.hpp:1180
armnn::IsNormalizationSupported
bool IsNormalizationSupported(const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const NormalizationDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::Convolution3dDescriptor
A Convolution3dDescriptor for the Convolution3dLayer.
Definition: Descriptors.hpp:551
armnn::IsMeanSupported
bool IsMeanSupported(const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const MeanDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::ILayerSupport::previousOutputIn
const TensorInfo & previousOutputIn
Definition: ILayerSupport.hpp:417
armnn::Pooling3dDescriptor
A Pooling3dDescriptor for the Pooling3dLayer.
Definition: Descriptors.hpp:392
armnn::IsConvolution2dSupported
bool IsConvolution2dSupported(const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const Convolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::ILayerSupport::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
armnn::SpaceToBatchNdDescriptor
A SpaceToBatchNdDescriptor for the SpaceToBatchNdLayer.
Definition: Descriptors.hpp:1019
armnn::IsInputSupported
bool IsInputSupported(const BackendId &backend, const TensorInfo &input, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::IsPermuteSupported
bool IsPermuteSupported(const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const PermuteDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::ILayerSupport::detectionScores
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo & detectionScores
Definition: ILayerSupport.hpp:184
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::ElementwiseUnaryDescriptor
A ElementwiseUnaryDescriptor for the ElementwiseUnaryLayer.
Definition: Descriptors.hpp:109
armnn::ILayerSupport::biases
const TensorInfo const Convolution2dDescriptor const TensorInfo const Optional< TensorInfo > & biases
Definition: ILayerSupport.hpp:137
armnn::IsConvertFp16ToFp32Supported
bool IsConvertFp16ToFp32Supported(const BackendId &backend, const TensorInfo &input, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::IsBatchToSpaceNdSupported
bool IsBatchToSpaceNdSupported(const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const BatchToSpaceNdDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::MeanDescriptor
A MeanDescriptor for the MeanLayer.
Definition: Descriptors.hpp:1124
armnn::ILayerSupport::detectionBoxes
const TensorInfo const TensorInfo const TensorInfo & detectionBoxes
Definition: ILayerSupport.hpp:184
armnn::IsFloorSupported
bool IsFloorSupported(const BackendId &backend, const TensorInfo &input, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::TransposeDescriptor
A TransposeDescriptor for the TransposeLayer.
Definition: Descriptors.hpp:1442
armnn::StridedSliceDescriptor
A StridedSliceDescriptor for the StridedSliceLayer.
Definition: Descriptors.hpp:1255
armnn::IsPreluSupported
bool IsPreluSupported(const BackendId &backend, const TensorInfo &input, const TensorInfo &alpha, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::IsSplitterSupported
bool IsSplitterSupported(const BackendId &backend, const TensorInfo &input, const std::vector< std::reference_wrapper< TensorInfo >> &outputs, const ViewsDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::IsReduceSupported
bool IsReduceSupported(const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const ReduceDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::ILayerSupport::input1
const TensorInfo & input1
Definition: ILayerSupport.hpp:48
armnn::IsConstantSupported
bool IsConstantSupported(const BackendId &backend, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::IsAdditionSupported
bool IsAdditionSupported(const BackendId &backend, const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::PreCompiledDescriptor
A PreCompiledDescriptor for the PreCompiledLayer.
Definition: Descriptors.hpp:1319
armnn::IsPooling2dSupported
bool IsPooling2dSupported(const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const Pooling2dDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::Pooling2dDescriptor
A Pooling2dDescriptor for the Pooling2dLayer.
Definition: Descriptors.hpp:332
armnn::NormalizationDescriptor
A NormalizationDescriptor for the NormalizationLayer.
Definition: Descriptors.hpp:729
armnn::ILayerSupport::scratchBuffer
const TensorInfo const TensorInfo const TensorInfo & scratchBuffer
Definition: ILayerSupport.hpp:298
armnn::DetectionPostProcessDescriptor
Definition: Descriptors.hpp:673
armnn::InstanceNormalizationDescriptor
An InstanceNormalizationDescriptor for InstanceNormalizationLayer.
Definition: Descriptors.hpp:807
armnn::ChannelShuffleDescriptor
A ChannelShuffleDescriptor for the ChannelShuffle operator.
Definition: Descriptors.hpp:1507
armnn::ILayerSupport::cellStateOut
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo & cellStateOut
Definition: ILayerSupport.hpp:298
armnn::SoftmaxDescriptor
A SoftmaxDescriptor for the SoftmaxLayer.
Definition: Descriptors.hpp:150
armnn::ILayerSupport::weights
const TensorInfo const Convolution2dDescriptor const TensorInfo & weights
Definition: ILayerSupport.hpp:137
armnn::IsActivationSupported
bool IsActivationSupported(const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const ActivationDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::IsPadSupported
bool IsPadSupported(const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const PadDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::DepthwiseConvolution2dDescriptor
A DepthwiseConvolution2dDescriptor for the DepthwiseConvolution2dLayer.
Definition: Descriptors.hpp:622
armnn::FillDescriptor
A FillDescriptor for the FillLayer.
Definition: Descriptors.hpp:885
armnn::BatchNormalizationDescriptor
A BatchNormalizationDescriptor for the BatchNormalizationLayer.
Definition: Descriptors.hpp:788
armnn::IsMultiplicationSupported
bool IsMultiplicationSupported(const BackendId &backend, const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
armnn::ILayerSupport::mean
const TensorInfo const TensorInfo & mean
Definition: ILayerSupport.hpp:62
armnn::PermuteDescriptor
A PermuteDescriptor for the PermuteLayer.
Definition: Descriptors.hpp:129
armnn::LayerType
LayerType
When adding a new layer, adapt also the LastLayer enum value in the enum class LayerType below...
Definition: Types.hpp:458
armnn::IsReshapeSupported
bool IsReshapeSupported(const BackendId &backend, const TensorInfo &input, const ReshapeDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.