ArmNN
 22.05
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  return IsUnidirectionalSequenceLstmSupported(infos[0],
492  infos[1],
493  infos[2],
494  infos[3],
495  infos[4],
496  infos[5],
497  desc,
498  lstmParamsInfo.value(),
499  reasonIfUnsupported);
500  }
501  case LayerType::ChannelShuffle:
502  return IsChannelShuffleSupported(infos[0],
503  infos[1],
504  *(PolymorphicDowncast<const ChannelShuffleDescriptor*>(&descriptor)),
505  reasonIfUnsupported);
506  case LayerType::Convolution3d:
507  {
508  if (infos.size() != 4)
509  {
510  throw InvalidArgumentException("Invalid number of Convolution3d "
511  "TensorInfos. TensorInfos should be of format: "
512  "{input, output, weights, biases}.");
513  }
514 
515  auto desc = *(PolymorphicDowncast<const Convolution3dDescriptor*>(&descriptor));
516  if (infos[3] == TensorInfo())
517  {
518  return IsConvolution3dSupported(infos[0],
519  infos[1],
520  desc,
521  infos[2],
522  EmptyOptional(),
523  reasonIfUnsupported);
524  }
525  else
526  {
527  return IsConvolution3dSupported(infos[0],
528  infos[1],
529  desc,
530  infos[2],
531  infos[3],
532  reasonIfUnsupported);
533  }
534  }
535  case LayerType::Pooling3d:
536  return IsPooling3dSupported(infos[0],
537  infos[1],
538  *(PolymorphicDowncast<const Pooling3dDescriptor*>(&descriptor)),
539  reasonIfUnsupported);
540  default:
541  return false;
542  }
543 }
544 
545 bool ILayerSupport::IsActivationSupported(const TensorInfo& input,
546  const TensorInfo& output,
547  const ActivationDescriptor& descriptor,
548  Optional<std::string&> reasonIfUnsupported) const
549 {
550  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
551  return false;
552 }
553 
554 bool ILayerSupport::IsAdditionSupported(const TensorInfo& input0,
555  const TensorInfo& input1,
556  const TensorInfo& output,
557  Optional<std::string&> reasonIfUnsupported) const
558 {
559  IgnoreUnused(input0, input1, output, reasonIfUnsupported);
560  return false;
561 }
562 
563 bool ILayerSupport::IsArgMinMaxSupported(const TensorInfo& input,
564  const TensorInfo& output,
565  const ArgMinMaxDescriptor& descriptor,
566  Optional<std::string&> reasonIfUnsupported) const
567 {
568  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
569  return false;
570 }
571 
572 bool ILayerSupport::IsBatchNormalizationSupported(const TensorInfo& input,
573  const TensorInfo& output,
574  const TensorInfo& mean,
575  const TensorInfo& var,
576  const TensorInfo& beta,
577  const TensorInfo& gamma,
578  const BatchNormalizationDescriptor& descriptor,
579  Optional<std::string&> reasonIfUnsupported) const
580 {
581  IgnoreUnused(input, output, mean, var, beta, gamma, descriptor, reasonIfUnsupported);
582  return false;
583 }
584 
585 bool ILayerSupport::IsBatchToSpaceNdSupported(const TensorInfo& input,
586  const TensorInfo& output,
587  const BatchToSpaceNdDescriptor& descriptor,
588  Optional<std::string&> reasonIfUnsupported) const
589 {
590  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
591  return false;
592 }
593 
594 bool ILayerSupport::IsCastSupported(const TensorInfo& input,
595  const TensorInfo& output,
596  Optional<std::string&> reasonIfUnsupported) const
597 {
598  IgnoreUnused(input, output, reasonIfUnsupported);
599  return false;
600 }
601 
602 bool ILayerSupport::IsChannelShuffleSupported(const TensorInfo& input,
603  const TensorInfo& output,
604  const ChannelShuffleDescriptor& descriptor,
605  Optional<std::string&> reasonIfUnsupported) const
606 {
607  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
608  return false;
609 }
610 
611 bool ILayerSupport::IsComparisonSupported(const TensorInfo& input0,
612  const TensorInfo& input1,
613  const TensorInfo& output,
614  const ComparisonDescriptor& descriptor,
615  Optional<std::string&> reasonIfUnsupported) const
616 {
617  IgnoreUnused(input0, input1, output, descriptor, reasonIfUnsupported);
618  return false;
619 }
620 
621 bool ILayerSupport::IsConcatSupported(const std::vector<const TensorInfo*> inputs,
622  const TensorInfo& output,
623  const OriginsDescriptor& descriptor,
624  Optional<std::string&> reasonIfUnsupported) const
625 {
626  IgnoreUnused(inputs, output, descriptor, reasonIfUnsupported);
627  return false;
628 }
629 
630 bool ILayerSupport::IsConstantSupported(const TensorInfo& output,
631  Optional<std::string&> reasonIfUnsupported) const
632 {
633  IgnoreUnused(output, reasonIfUnsupported);
634  return false;
635 }
636 
637 bool ILayerSupport::IsConvertBf16ToFp32Supported(const TensorInfo& input,
638  const TensorInfo& output,
639  Optional<std::string&> reasonIfUnsupported) const
640 {
641  IgnoreUnused(input, output, reasonIfUnsupported);
642  return false;
643 }
644 
645 bool ILayerSupport::IsConvertFp32ToBf16Supported(const TensorInfo& input,
646  const TensorInfo& output,
647  Optional<std::string&> reasonIfUnsupported) const
648 {
649  IgnoreUnused(input, output, reasonIfUnsupported);
650  return false;
651 }
652 
653 bool ILayerSupport::IsConvertFp16ToFp32Supported(const TensorInfo& input,
654  const TensorInfo& output,
655  Optional<std::string&> reasonIfUnsupported) const
656 {
657  IgnoreUnused(input, output, reasonIfUnsupported);
658  return false;
659 }
660 
661 bool ILayerSupport::IsConvertFp32ToFp16Supported(const TensorInfo& input,
662  const TensorInfo& output,
663  Optional<std::string&> reasonIfUnsupported) const
664 {
665  IgnoreUnused(input, output, reasonIfUnsupported);
666  return false;
667 }
668 
669 bool ILayerSupport::IsConvolution2dSupported(const TensorInfo& input,
670  const TensorInfo& output,
671  const Convolution2dDescriptor& descriptor,
672  const TensorInfo& weights,
673  const Optional<TensorInfo>& biases,
674  Optional<std::string&> reasonIfUnsupported) const
675 {
676  IgnoreUnused(input, output, descriptor, weights, biases, reasonIfUnsupported);
677  return false;
678 }
679 
680 bool ILayerSupport::IsConvolution3dSupported(const TensorInfo& input,
681  const TensorInfo& output,
682  const Convolution3dDescriptor& descriptor,
683  const TensorInfo& weights,
684  const Optional<TensorInfo>& biases,
685  Optional<std::string&> reasonIfUnsupported) const
686 {
687  IgnoreUnused(input, output, descriptor, weights, biases, reasonIfUnsupported);
688  return false;
689 }
690 
691 bool ILayerSupport::IsDebugSupported(const TensorInfo& input,
692  const TensorInfo& output,
693  Optional<std::string&> reasonIfUnsupported) const
694 {
695  IgnoreUnused(input, output, reasonIfUnsupported);
696  return false;
697 }
698 
699 bool ILayerSupport::IsDepthToSpaceSupported(const TensorInfo& input,
700  const TensorInfo& output,
701  const DepthToSpaceDescriptor& descriptor,
702  Optional<std::string&> reasonIfUnsupported) const
703 {
704  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
705  return false;
706 }
707 
708 bool ILayerSupport::IsDepthwiseConvolutionSupported(
709  const TensorInfo& input,
710  const TensorInfo& output,
711  const DepthwiseConvolution2dDescriptor& descriptor,
712  const TensorInfo& weights,
713  const Optional<TensorInfo>& biases,
714  Optional<std::string&> reasonIfUnsupported) const
715 {
716  IgnoreUnused(input,
717  output,
718  descriptor,
719  weights,
720  biases,
721  reasonIfUnsupported);
722  return false;
723 }
724 
725 bool ILayerSupport::IsDequantizeSupported(const TensorInfo& input,
726  const TensorInfo& output,
727  Optional<std::string&> reasonIfUnsupported) const
728 {
729  IgnoreUnused(input, output, reasonIfUnsupported);
730  return false;
731 }
732 
733 bool ILayerSupport::IsDetectionPostProcessSupported(const TensorInfo& boxEncodings,
734  const TensorInfo& scores,
735  const TensorInfo& anchors,
736  const TensorInfo& detectionBoxes,
737  const TensorInfo& detectionClasses,
738  const TensorInfo& detectionScores,
739  const TensorInfo& numDetections,
740  const DetectionPostProcessDescriptor& descriptor,
741  Optional<std::string&> reasonIfUnsupported) const
742 {
743  IgnoreUnused(boxEncodings,
744  scores,
745  anchors,
746  detectionBoxes,
747  detectionClasses,
748  detectionScores,
749  numDetections,
750  descriptor,
751  reasonIfUnsupported);
752  return false;
753 }
754 
755 bool ILayerSupport::IsDilatedDepthwiseConvolutionSupported(
756  const TensorInfo& input,
757  const TensorInfo& output,
758  const DepthwiseConvolution2dDescriptor& descriptor,
759  const TensorInfo& weights,
760  const Optional<TensorInfo>& biases,
761  Optional<std::string&> reasonIfUnsupported) const
762 {
763  IgnoreUnused(input, output, descriptor, weights, biases, reasonIfUnsupported);
764  return false;
765 }
766 
767 bool ILayerSupport::IsDivisionSupported(const TensorInfo& input0,
768  const TensorInfo& input1,
769  const TensorInfo& output,
770  Optional<std::string&> reasonIfUnsupported) const
771 {
772  IgnoreUnused(input0, input1, output, reasonIfUnsupported);
773  return false;
774 }
775 
776 bool ILayerSupport::IsElementwiseUnarySupported(const TensorInfo& input,
777  const TensorInfo& output,
778  const ElementwiseUnaryDescriptor& descriptor,
779  Optional<std::string&> reasonIfUnsupported) const
780 {
781  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
782  return false;
783 }
784 
785 bool ILayerSupport::IsFakeQuantizationSupported(const TensorInfo& input,
786  const FakeQuantizationDescriptor& descriptor,
787  Optional<std::string&> reasonIfUnsupported) const
788 {
789  IgnoreUnused(input, descriptor, reasonIfUnsupported);
790  return false;
791 }
792 
793 bool ILayerSupport::IsFillSupported(const TensorInfo& input,
794  const TensorInfo& output,
795  const FillDescriptor& descriptor,
796  Optional<std::string&> reasonIfUnsupported) const
797 {
798  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
799  return false;
800 }
801 
802 bool ILayerSupport::IsFloorSupported(const TensorInfo& input,
803  const TensorInfo& output,
804  Optional<std::string&> reasonIfUnsupported) const
805 {
806  IgnoreUnused(input, output, reasonIfUnsupported);
807  return false;
808 }
809 
810 bool ILayerSupport::IsFullyConnectedSupported(const TensorInfo& input,
811  const TensorInfo& output,
812  const TensorInfo& weights,
813  const TensorInfo& biases,
814  const FullyConnectedDescriptor& descriptor,
815  Optional<std::string&> reasonIfUnsupported) const
816 {
817  IgnoreUnused(input, output, weights, biases, descriptor, reasonIfUnsupported);
818  return false;
819 }
820 
821 bool ILayerSupport::IsGatherSupported(const TensorInfo& input0,
822  const TensorInfo& input1,
823  const TensorInfo& output,
824  const GatherDescriptor& descriptor,
825  Optional<std::string&> reasonIfUnsupported) const
826 {
827  IgnoreUnused(input0, input1, output, descriptor, reasonIfUnsupported);
828  return false;
829 }
830 
831 bool ILayerSupport::IsInputSupported(const TensorInfo& input,
832  Optional<std::string&> reasonIfUnsupported) const
833 {
834  IgnoreUnused(input, reasonIfUnsupported);
835  return false;
836 }
837 
838 bool ILayerSupport::IsInstanceNormalizationSupported(
839  const TensorInfo& input,
840  const TensorInfo& output,
841  const InstanceNormalizationDescriptor& descriptor,
842  Optional<std::string&> reasonIfUnsupported) const
843 {
844  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
845  return false;
846 }
847 
848 bool ILayerSupport::IsL2NormalizationSupported(const TensorInfo& input,
849  const TensorInfo& output,
850  const L2NormalizationDescriptor& descriptor,
851  Optional<std::string&> reasonIfUnsupported) const
852 {
853  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
854  return false;
855 }
856 
857 bool ILayerSupport::IsLogicalBinarySupported(const TensorInfo& input0,
858  const TensorInfo& input1,
859  const TensorInfo& output,
860  const LogicalBinaryDescriptor& descriptor,
861  Optional<std::string&> reasonIfUnsupported) const
862 {
863  IgnoreUnused(input0, input1, output, descriptor, reasonIfUnsupported);
864  return false;
865 }
866 
867 bool ILayerSupport::IsLogicalUnarySupported(const TensorInfo& input,
868  const TensorInfo& output,
869  const ElementwiseUnaryDescriptor& descriptor,
870  Optional<std::string&> reasonIfUnsupported) const
871 {
872  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
873  return false;
874 }
875 
876 bool ILayerSupport::IsLogSoftmaxSupported(const TensorInfo& input,
877  const TensorInfo& output,
878  const LogSoftmaxDescriptor& descriptor,
879  Optional<std::string&> reasonIfUnsupported) const
880 {
881  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
882  return false;
883 }
884 
885 bool ILayerSupport::IsLstmSupported(const TensorInfo& input,
886  const TensorInfo& outputStateIn,
887  const TensorInfo& cellStateIn,
888  const TensorInfo& scratchBuffer,
889  const TensorInfo& outputStateOut,
890  const TensorInfo& cellStateOut,
891  const TensorInfo& output,
892  const LstmDescriptor& descriptor,
893  const LstmInputParamsInfo& paramsInfo,
894  Optional<std::string&> reasonIfUnsupported) const
895 {
896  IgnoreUnused(input,
897  outputStateIn,
898  cellStateIn,
899  scratchBuffer,
900  outputStateOut,
901  cellStateOut,
902  output,
903  descriptor,
904  paramsInfo,
905  reasonIfUnsupported);
906  return false;
907 }
908 
909 bool ILayerSupport::IsMaximumSupported(const TensorInfo& input0,
910  const TensorInfo& input1,
911  const TensorInfo& output,
912  Optional<std::string&> reasonIfUnsupported) const
913 {
914  IgnoreUnused(input0, input1, output, reasonIfUnsupported);
915  return false;
916 }
917 
918 bool ILayerSupport::IsMeanSupported(const TensorInfo& input,
919  const TensorInfo& output,
920  const MeanDescriptor& descriptor,
921  Optional<std::string&> reasonIfUnsupported) const
922 {
923  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
924  return false;
925 }
926 
927 bool ILayerSupport::IsMemCopySupported(const TensorInfo& input,
928  const TensorInfo& output,
929  Optional<std::string&> reasonIfUnsupported) const
930 {
931  IgnoreUnused(input, output, reasonIfUnsupported);
932  return false;
933 }
934 
935 bool ILayerSupport::IsMemImportSupported(const TensorInfo& input,
936  const TensorInfo& output,
937  Optional<std::string&> reasonIfUnsupported) const
938 {
939  IgnoreUnused(input, output, reasonIfUnsupported);
940  return false;
941 }
942 
943 bool ILayerSupport::IsMergeSupported(const TensorInfo& input0,
944  const TensorInfo& input1,
945  const TensorInfo& output,
946  Optional<std::string&> reasonIfUnsupported) const
947 {
948  IgnoreUnused(input0, input1, output, reasonIfUnsupported);
949  return false;
950 }
951 
952 bool ILayerSupport::IsMinimumSupported(const TensorInfo& input0,
953  const TensorInfo& input1,
954  const TensorInfo& output,
955  Optional<std::string&> reasonIfUnsupported) const
956 {
957  IgnoreUnused(input0, input1, output, reasonIfUnsupported);
958  return false;
959 }
960 
961 bool ILayerSupport::IsMultiplicationSupported(const TensorInfo& input0,
962  const TensorInfo& input1,
963  const TensorInfo& output,
964  Optional<std::string&> reasonIfUnsupported) const
965 {
966  IgnoreUnused(input0, input1, output, reasonIfUnsupported);
967  return false;
968 }
969 
970 bool ILayerSupport::IsNormalizationSupported(const TensorInfo& input,
971  const TensorInfo& output,
972  const NormalizationDescriptor& descriptor,
973  Optional<std::string&> reasonIfUnsupported) const
974 {
975  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
976  return false;
977 }
978 
979 bool ILayerSupport::IsOutputSupported(const TensorInfo& output,
980  Optional<std::string&> reasonIfUnsupported) const
981 {
982  IgnoreUnused(output, reasonIfUnsupported);
983  return false;
984 }
985 
986 bool ILayerSupport::IsPadSupported(const TensorInfo& input,
987  const TensorInfo& output,
988  const PadDescriptor& descriptor,
989  Optional<std::string&> reasonIfUnsupported) const
990 {
991  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
992  return false;
993 }
994 
995 bool ILayerSupport::IsPermuteSupported(const TensorInfo& input,
996  const TensorInfo& output,
997  const PermuteDescriptor& descriptor,
998  Optional<std::string&> reasonIfUnsupported) const
999 {
1000  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
1001  return false;
1002 }
1003 
1004 bool ILayerSupport::IsPooling2dSupported(const TensorInfo& input,
1005  const TensorInfo& output,
1006  const Pooling2dDescriptor& descriptor,
1007  Optional<std::string&> reasonIfUnsupported) const
1008 {
1009  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
1010  return false;
1011 }
1012 
1013 bool ILayerSupport::IsPooling3dSupported(const TensorInfo& input,
1014  const TensorInfo& output,
1015  const Pooling3dDescriptor& descriptor,
1016  Optional<std::string&> reasonIfUnsupported) const
1017 {
1018  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
1019  return false;
1020 }
1021 
1022 bool ILayerSupport::IsPreCompiledSupported(const TensorInfo& input,
1023  const PreCompiledDescriptor& descriptor,
1024  Optional<std::string&> reasonIfUnsupported) const
1025 {
1026  IgnoreUnused(input, descriptor, reasonIfUnsupported);
1027  return false;
1028 }
1029 
1030 bool ILayerSupport::IsPreluSupported(const TensorInfo& input,
1031  const TensorInfo& alpha,
1032  const TensorInfo& output,
1033  Optional<std::string&> reasonIfUnsupported) const
1034 {
1035  IgnoreUnused(input, alpha, output, reasonIfUnsupported);
1036  return false;
1037 }
1038 
1039 bool ILayerSupport::IsQuantizeSupported(const TensorInfo& input,
1040  const TensorInfo& output,
1041  Optional<std::string&> reasonIfUnsupported) const
1042 {
1043  IgnoreUnused(input, output, reasonIfUnsupported);
1044  return false;
1045 }
1046 
1047 bool ILayerSupport::IsQLstmSupported(const TensorInfo& input,
1048  const TensorInfo& previousOutputIn,
1049  const TensorInfo& previousCellStateIn,
1050  const TensorInfo& outputStateOut,
1051  const TensorInfo& cellStateOut,
1052  const TensorInfo& output,
1053  const QLstmDescriptor& descriptor,
1054  const LstmInputParamsInfo& paramsInfo,
1055  Optional<std::string&> reasonIfUnsupported) const
1056 {
1057  IgnoreUnused(input,
1058  previousOutputIn,
1059  previousCellStateIn,
1060  outputStateOut,
1061  cellStateOut,
1062  output,
1063  descriptor,
1064  paramsInfo,
1065  reasonIfUnsupported);
1066  return false;
1067 }
1068 
1069 bool ILayerSupport::IsQuantizedLstmSupported(const TensorInfo& input,
1070  const TensorInfo& previousCellStateIn,
1071  const TensorInfo& previousOutputIn,
1072  const TensorInfo& cellStateOut,
1073  const TensorInfo& output,
1074  const QuantizedLstmInputParamsInfo& paramsInfo,
1075  Optional<std::string&> reasonIfUnsupported) const
1076 {
1077  IgnoreUnused(input,
1078  previousCellStateIn,
1079  previousOutputIn,
1080  cellStateOut,
1081  output,
1082  paramsInfo,
1083  reasonIfUnsupported);
1084  return false;
1085 }
1086 
1087 bool ILayerSupport::IsRankSupported(const TensorInfo& input,
1088  const TensorInfo& output,
1089  Optional<std::string&> reasonIfUnsupported) const
1090 {
1091  IgnoreUnused(input, output, reasonIfUnsupported);
1092  return false;
1093 }
1094 
1095 bool ILayerSupport::IsReduceSupported(const TensorInfo& input,
1096  const TensorInfo& output,
1097  const ReduceDescriptor& descriptor,
1098  Optional<std::string&> reasonIfUnsupported) const
1099 {
1100  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
1101  return false;
1102 }
1103 
1104 bool ILayerSupport::IsReshapeSupported(const TensorInfo& input,
1105  const TensorInfo& output,
1106  const ReshapeDescriptor& descriptor,
1107  Optional<std::string&> reasonIfUnsupported) const
1108 {
1109  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
1110  return false;
1111 }
1112 
1113 bool ILayerSupport::IsResizeSupported(const TensorInfo& input,
1114  const TensorInfo& output,
1115  const ResizeDescriptor& descriptor,
1116  Optional<std::string&> reasonIfUnsupported) const
1117 {
1118  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
1119  return false;
1120 }
1121 
1122 bool ILayerSupport::IsShapeSupported(const TensorInfo& input,
1123  const TensorInfo& output,
1124  Optional<std::string&> reasonIfUnsupported) const
1125 {
1126  IgnoreUnused(input, output, reasonIfUnsupported);
1127  return false;
1128 }
1129 
1130 bool ILayerSupport::IsSliceSupported(const TensorInfo& input,
1131  const TensorInfo& output,
1132  const SliceDescriptor& descriptor,
1133  Optional<std::string&> reasonIfUnsupported) const
1134 {
1135  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
1136  return false;
1137 }
1138 
1139 bool ILayerSupport::IsSoftmaxSupported(const TensorInfo& input,
1140  const TensorInfo& output,
1141  const SoftmaxDescriptor& descriptor,
1142  Optional<std::string&> reasonIfUnsupported) const
1143 {
1144  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
1145  return false;
1146 }
1147 
1148 bool ILayerSupport::IsSpaceToBatchNdSupported(const TensorInfo& input,
1149  const TensorInfo& output,
1150  const SpaceToBatchNdDescriptor& descriptor,
1151  Optional<std::string&> reasonIfUnsupported) const
1152 {
1153  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
1154  return false;
1155 }
1156 
1157 bool ILayerSupport::IsSpaceToDepthSupported(const TensorInfo& input,
1158  const TensorInfo& output,
1159  const SpaceToDepthDescriptor& descriptor,
1160  Optional<std::string&> reasonIfUnsupported) const
1161 {
1162  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
1163  return false;
1164 }
1165 
1166 bool ILayerSupport::IsSplitterSupported(const TensorInfo& input,
1167  const std::vector<std::reference_wrapper<TensorInfo>>& outputs,
1168  const ViewsDescriptor& descriptor,
1169  Optional<std::string&> reasonIfUnsupported) const
1170 {
1171  IgnoreUnused(input, outputs, descriptor, reasonIfUnsupported);
1172  return false;
1173 }
1174 
1175 bool ILayerSupport::IsStackSupported(const std::vector<const TensorInfo*>& inputs,
1176  const TensorInfo& output,
1177  const StackDescriptor& descriptor,
1178  Optional<std::string&> reasonIfUnsupported) const
1179 {
1180  IgnoreUnused(inputs, output, descriptor, reasonIfUnsupported);
1181  return false;
1182 }
1183 
1184 bool ILayerSupport::IsStandInSupported(const std::vector<const TensorInfo*>& inputs,
1185  const std::vector<const TensorInfo*>& outputs,
1186  const StandInDescriptor& descriptor,
1187  Optional<std::string&> reasonIfUnsupported) const
1188 {
1189  IgnoreUnused(inputs, outputs, descriptor, reasonIfUnsupported);
1190  return false;
1191 }
1192 
1193 bool ILayerSupport::IsStridedSliceSupported(const TensorInfo& input,
1194  const TensorInfo& output,
1195  const StridedSliceDescriptor& descriptor,
1196  Optional<std::string&> reasonIfUnsupported) const
1197 {
1198  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
1199  return false;
1200 }
1201 
1202 bool ILayerSupport::IsSubtractionSupported(const TensorInfo& input0,
1203  const TensorInfo& input1,
1204  const TensorInfo& output,
1205  Optional<std::string&> reasonIfUnsupported) const
1206 {
1207  IgnoreUnused(input0, input1, output, reasonIfUnsupported);
1208  return false;
1209 }
1210 
1211 bool ILayerSupport::IsSwitchSupported(const TensorInfo& input0,
1212  const TensorInfo& input1,
1213  const TensorInfo& output0,
1214  const TensorInfo& output1,
1215  Optional<std::string&> reasonIfUnsupported) const
1216 {
1217  IgnoreUnused(input0, input1, output0, output1, reasonIfUnsupported);
1218  return false;
1219 }
1220 
1221 bool ILayerSupport::IsTransposeConvolution2dSupported(
1222  const TensorInfo& input,
1223  const TensorInfo& output,
1224  const TransposeConvolution2dDescriptor& descriptor,
1225  const TensorInfo& weights,
1226  const Optional<TensorInfo>& biases,
1227  Optional<std::string&> reasonIfUnsupported) const
1228 {
1229  IgnoreUnused(input, output, descriptor, weights, biases, reasonIfUnsupported);
1230  return false;
1231 }
1232 
1233 bool ILayerSupport::IsTransposeSupported(const TensorInfo& input,
1234  const TensorInfo& output,
1235  const TransposeDescriptor& descriptor,
1236  Optional<std::string&> reasonIfUnsupported) const
1237 {
1238  IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
1239  return false;
1240 }
1241 
1242 bool ILayerSupport::IsUnidirectionalSequenceLstmSupported(
1243  const TensorInfo& input,
1244  const TensorInfo& outputStateIn,
1245  const TensorInfo& cellStateIn,
1246  const TensorInfo& outputStateOut,
1247  const TensorInfo& cellStateOut,
1248  const TensorInfo& output,
1249  const LstmDescriptor& descriptor,
1250  const LstmInputParamsInfo& paramsInfo,
1251  Optional<std::string&> reasonIfUnsupported) const
1252 {
1253  IgnoreUnused(input,
1254  outputStateIn,
1255  cellStateIn,
1256  outputStateOut,
1257  cellStateOut,
1258  output,
1259  descriptor,
1260  paramsInfo,
1261  reasonIfUnsupported);
1262  return false;
1263 }
1264 ARMNN_NO_DEPRECATE_WARN_END
1265 }
IgnoreUnused.hpp
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:1421
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::output
const TensorInfo & output
Definition: ILayerSupport.hpp:41
armnn::ReshapeDescriptor
A ReshapeDescriptor for the ReshapeLayer.
Definition: Descriptors.hpp:1004
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::LogicalBinaryDescriptor
A LogicalBinaryDescriptor for the LogicalBinaryLayer.
Definition: Descriptors.hpp:1492
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:1056
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:840
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:966
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:1232
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:1177
armnn::ILayerSupport::cellStateIn
const TensorInfo const TensorInfo & cellStateIn
Definition: ILayerSupport.hpp:298
armnn::LstmDescriptor
An LstmDescriptor for the LstmLayer.
Definition: Descriptors.hpp:1083
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:774
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:1512
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::ILayerSupport::outputStateOut
const TensorInfo const TensorInfo const TensorInfo const TensorInfo & outputStateOut
Definition: ILayerSupport.hpp:298
armnn::FakeQuantizationDescriptor
A FakeQuantizationDescriptor for the FakeQuantizationLayer.
Definition: Descriptors.hpp:871
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::ILayerSupport::cellStateOut
const TensorInfo const TensorInfo const TensorInfo const TensorInfo const TensorInfo & cellStateOut
Definition: ILayerSupport.hpp:298
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:909
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:1262
armnn::QLstmDescriptor
A QLstmDescriptor for the QLstmLayer.
Definition: Descriptors.hpp:1361
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:1209
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:553
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::SpaceToBatchNdDescriptor
A SpaceToBatchNdDescriptor for the SpaceToBatchNdLayer.
Definition: Descriptors.hpp:1024
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:1153
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:1471
armnn::StridedSliceDescriptor
A StridedSliceDescriptor for the StridedSliceLayer.
Definition: Descriptors.hpp:1284
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:1348
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:734
armnn::ILayerSupport::scratchBuffer
const TensorInfo const TensorInfo const TensorInfo & scratchBuffer
Definition: ILayerSupport.hpp:298
armnn::DetectionPostProcessDescriptor
Definition: Descriptors.hpp:678
armnn::InstanceNormalizationDescriptor
An InstanceNormalizationDescriptor for InstanceNormalizationLayer.
Definition: Descriptors.hpp:812
armnn::ChannelShuffleDescriptor
A ChannelShuffleDescriptor for the ChannelShuffle operator.
Definition: Descriptors.hpp:1536
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:624
armnn::FillDescriptor
A FillDescriptor for the FillLayer.
Definition: Descriptors.hpp:890
armnn::BatchNormalizationDescriptor
A BatchNormalizationDescriptor for the BatchNormalizationLayer.
Definition: Descriptors.hpp:793
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:467
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.