Gitiles
Code Review Sign In
review.mlplatform.org / ml / armnn / ce5045a00485f8a8c35814c0781ccbcca5678e5c / . / src / backends / backendsCommon / LayerSupportBase.cpp
blob: c41f0b11eae459bfe4e5f560f775118d9c1c18e5 [file] [log] [blame]
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]1//
2// Copyright © 2017 Arm Ltd. All rights reserved.
3// SPDX-License-Identifier: MIT
4//
5
6#include "LayerSupportBase.hpp"
7
8#include <armnn/Exceptions.hpp>
9
Derek Lambertif674aa02019-08-01 15:56:25 +0100[diff] [blame]10#include <boost/core/ignore_unused.hpp>
11
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]12namespace
13{
14
15bool DefaultLayerSupport(const char* func,
16 const char* file,
17 unsigned int line,
18 armnn::Optional<std::string&> reasonIfUnsupported)
19{
20 // NOTE: We only need to return the reason if the optional parameter is not empty
21 if (reasonIfUnsupported)
22 {
23 std::stringstream message;
24 message << func << " is not implemented [" << file << ":" << line << "]";
25
26 reasonIfUnsupported.value() = message.str();
27 }
28
29 return false;
30}
31
32} // anonymous namespace
33
34namespace armnn
35{
36
Kevin May868eb142019-09-04 17:29:31 +0100[diff] [blame]37bool LayerSupportBase::IsAbsSupported(const TensorInfo &input,
38 const TensorInfo &output,
39 Optional<std::string &> reasonIfUnsupported) const
40{
41 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
42}
43
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]44bool LayerSupportBase::IsActivationSupported(const TensorInfo& input,
45 const TensorInfo& output,
46 const ActivationDescriptor& descriptor,
47 Optional<std::string&> reasonIfUnsupported) const
48{
49 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
50}
51
52bool LayerSupportBase::IsAdditionSupported(const TensorInfo& input0,
53 const TensorInfo& input1,
54 const TensorInfo& output,
55 Optional<std::string&> reasonIfUnsupported) const
56{
57 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
58}
59
Nikhil Rajee391d52019-09-05 17:50:44 +0100[diff] [blame]60bool LayerSupportBase::IsArgMinMaxSupported(const armnn::TensorInfo &input, const armnn::TensorInfo &output,
61 const armnn::ArgMinMaxDescriptor& descriptor,
62 armnn::Optional<std::string &> reasonIfUnsupported) const
63{
64 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
65}
66
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]67bool LayerSupportBase::IsBatchNormalizationSupported(const TensorInfo& input,
68 const TensorInfo& output,
69 const TensorInfo& mean,
70 const TensorInfo& var,
71 const TensorInfo& beta,
72 const TensorInfo& gamma,
73 const BatchNormalizationDescriptor& descriptor,
74 Optional<std::string&> reasonIfUnsupported) const
75{
76 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
77}
78
79bool LayerSupportBase::IsBatchToSpaceNdSupported(const TensorInfo& input,
80 const TensorInfo& output,
81 const BatchToSpaceNdDescriptor& descriptor,
82 Optional<std::string&> reasonIfUnsupported) const
83{
84 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
85}
86
Jim Flynn906f9462019-05-10 13:55:21 +0100[diff] [blame]87bool LayerSupportBase::IsConcatSupported(const std::vector<const TensorInfo*> inputs,
88 const TensorInfo& output,
89 const OriginsDescriptor& descriptor,
90 Optional<std::string&> reasonIfUnsupported) const
91{
Jim Flynne242f2d2019-05-22 14:24:13 +0100[diff] [blame]92 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
Jim Flynn906f9462019-05-10 13:55:21 +0100[diff] [blame]93}
94
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]95bool LayerSupportBase::IsConstantSupported(const TensorInfo& output,
96 Optional<std::string&> reasonIfUnsupported) const
97{
98 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
99}
100
101bool LayerSupportBase::IsConvertFp16ToFp32Supported(const TensorInfo& input,
102 const TensorInfo& output,
103 Optional<std::string&> reasonIfUnsupported) const
104{
105 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
106}
107
108bool LayerSupportBase::IsConvertFp32ToFp16Supported(const TensorInfo& input,
109 const TensorInfo& output,
110 Optional<std::string&> reasonIfUnsupported) const
111{
112 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
113}
114
115bool LayerSupportBase::IsConvolution2dSupported(const TensorInfo& input,
116 const TensorInfo& output,
117 const Convolution2dDescriptor& descriptor,
118 const TensorInfo& weights,
119 const Optional<TensorInfo>& biases,
120 Optional<std::string&> reasonIfUnsupported) const
121{
122 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
123}
124
125bool LayerSupportBase::IsDebugSupported(const TensorInfo& input,
126 const TensorInfo& output,
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]127 Optional<std::string&> reasonIfUnsupported) const
128{
129 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
130}
131
Aron Virginas-Tardd6247f2019-09-19 14:31:17 +0100[diff] [blame]132bool LayerSupportBase::IsDepthToSpaceSupported(const TensorInfo& input,
133 const TensorInfo& output,
134 const DepthToSpaceDescriptor& descriptor,
135 Optional<std::string&> reasonIfUnsupported) const
136{
137 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
138}
139
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]140bool LayerSupportBase::IsDepthwiseConvolutionSupported(const TensorInfo& input,
141 const TensorInfo& output,
142 const DepthwiseConvolution2dDescriptor& descriptor,
143 const TensorInfo& weights,
144 const Optional<TensorInfo>& biases,
145 Optional<std::string&> reasonIfUnsupported) const
146{
147 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
148}
149
Nattapat Chaimanowonge4294fd2019-03-28 09:56:53 +0000[diff] [blame]150bool LayerSupportBase::IsDequantizeSupported(const TensorInfo& input,
151 const TensorInfo& output,
152 Optional<std::string&> reasonIfUnsupported) const
153{
154 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
155}
156
Narumol Prangnawarat94dd5d82019-01-23 18:06:26 +0000[diff] [blame]157bool LayerSupportBase::IsDetectionPostProcessSupported(const armnn::TensorInfo& input0,
158 const armnn::TensorInfo& input1,
159 const armnn::DetectionPostProcessDescriptor& descriptor,
160 armnn::Optional<std::string&> reasonIfUnsupported) const
161{
162 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
163}
164
Matteo Martincigheac246d2019-05-14 09:11:03 +0100[diff] [blame]165bool LayerSupportBase::IsDilatedDepthwiseConvolutionSupported(const TensorInfo& input,
166 const TensorInfo& output,
167 const DepthwiseConvolution2dDescriptor& descriptor,
168 const TensorInfo& weights,
169 const Optional<TensorInfo>& biases,
170 Optional<std::string&> reasonIfUnsupported) const
171{
172 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
173}
174
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]175bool LayerSupportBase::IsDivisionSupported(const TensorInfo& input0,
176 const TensorInfo& input1,
177 const TensorInfo& output,
178 Optional<std::string&> reasonIfUnsupported) const
179{
180 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
181}
182
183bool LayerSupportBase::IsEqualSupported(const armnn::TensorInfo& input0,
184 const armnn::TensorInfo& input1,
185 const armnn::TensorInfo& output,
186 armnn::Optional<std::string &> reasonIfUnsupported) const
187{
188 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
189}
190
191bool LayerSupportBase::IsFakeQuantizationSupported(const TensorInfo& input,
192 const FakeQuantizationDescriptor& descriptor,
193 Optional<std::string&> reasonIfUnsupported) const
194{
195 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
196}
197
198bool LayerSupportBase::IsFloorSupported(const TensorInfo& input,
199 const TensorInfo& output,
200 Optional<std::string&> reasonIfUnsupported) const
201{
202 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
203}
204
205bool LayerSupportBase::IsFullyConnectedSupported(const TensorInfo& input,
206 const TensorInfo& output,
207 const TensorInfo& weights,
208 const TensorInfo& biases,
209 const FullyConnectedDescriptor& descriptor,
210 Optional<std::string&> reasonIfUnsupported) const
211{
212 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
213}
214
narpra01b89b05f2019-01-16 09:53:09 +0000[diff] [blame]215bool LayerSupportBase::IsGatherSupported(const armnn::TensorInfo& input0,
216 const armnn::TensorInfo& input1,
217 const armnn::TensorInfo& output,
218 armnn::Optional<std::string&> reasonIfUnsupported) const
219{
220 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
221}
222
Matteo Martincigh3d6898c2019-01-15 16:11:44 +0000[diff] [blame]223bool LayerSupportBase::IsGreaterSupported(const TensorInfo& input0,
224 const TensorInfo& input1,
225 const TensorInfo& output,
226 Optional<std::string&> reasonIfUnsupported) const
227{
228 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
229}
230
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]231bool LayerSupportBase::IsInputSupported(const TensorInfo& input,
232 Optional<std::string&> reasonIfUnsupported) const
233{
234 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
235}
236
Kevin Mayce5045a2019-10-02 14:07:47 +0100[diff] [blame^]237bool LayerSupportBase::IsInstanceNormalizationSupported(const TensorInfo& input,
238 const TensorInfo& output,
239 const InstanceNormalizationDescriptor& descriptor,
240 Optional<std::string&> reasonIfUnsupported) const
241{
242 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
243}
244
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]245bool LayerSupportBase::IsL2NormalizationSupported(const TensorInfo& input,
246 const TensorInfo& output,
247 const L2NormalizationDescriptor& descriptor,
248 Optional<std::string&> reasonIfUnsupported) const
249{
250 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
251}
252
253bool LayerSupportBase::IsLstmSupported(const TensorInfo& input,
254 const TensorInfo& outputStateIn,
255 const TensorInfo& cellStateIn,
256 const TensorInfo& scratchBuffer,
257 const TensorInfo& outputStateOut,
258 const TensorInfo& cellStateOut,
259 const TensorInfo& output,
260 const LstmDescriptor& descriptor,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]261 const LstmInputParamsInfo& paramsInfo,
262 Optional<std::string&> reasonIfUnsupported) const
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]263{
264 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
265}
266
267bool LayerSupportBase::IsMaximumSupported(const TensorInfo& input0,
268 const TensorInfo& input1,
269 const TensorInfo& output,
270 Optional<std::string&> reasonIfUnsupported) const
271{
272 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
273}
274
275bool LayerSupportBase::IsMeanSupported(const TensorInfo& input,
276 const TensorInfo& output,
277 const MeanDescriptor& descriptor,
278 Optional<std::string&> reasonIfUnsupported) const
279{
280 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
281}
282
283bool LayerSupportBase::IsMemCopySupported(const armnn::TensorInfo& input,
284 const armnn::TensorInfo& output,
285 armnn::Optional<std::string &> reasonIfUnsupported) const
286{
Derek Lambertif674aa02019-08-01 15:56:25 +0100[diff] [blame]287 boost::ignore_unused(input);
288 boost::ignore_unused(output);
289 return true;
290}
291
292bool LayerSupportBase::IsMemImportSupported(const armnn::TensorInfo& input,
293 const armnn::TensorInfo& output,
294 armnn::Optional<std::string &> reasonIfUnsupported) const
295{
296 boost::ignore_unused(input);
297 boost::ignore_unused(output);
298 return true;
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]299}
300
Nattapat Chaimanowong1f886302019-04-05 13:37:19 +0100[diff] [blame]301bool LayerSupportBase::IsMergeSupported(const TensorInfo& input0,
302 const TensorInfo& input1,
303 const TensorInfo& output,
304 Optional<std::string&> reasonIfUnsupported) const
305{
306 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
307}
308
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]309bool LayerSupportBase::IsMergerSupported(const std::vector<const TensorInfo*> inputs,
310 const TensorInfo& output,
311 const OriginsDescriptor& descriptor,
312 Optional<std::string&> reasonIfUnsupported) const
313{
Jim Flynne242f2d2019-05-22 14:24:13 +0100[diff] [blame]314 return IsConcatSupported(inputs, output, descriptor, reasonIfUnsupported);
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]315}
316
317bool LayerSupportBase::IsMinimumSupported(const TensorInfo& input0,
318 const TensorInfo& input1,
319 const TensorInfo& output,
320 Optional<std::string&> reasonIfUnsupported) const
321{
322 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
323}
324
325bool LayerSupportBase::IsMultiplicationSupported(const TensorInfo& input0,
326 const TensorInfo& input1,
327 const TensorInfo& output,
328 Optional<std::string&> reasonIfUnsupported) const
329{
330 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
331}
332
333bool LayerSupportBase::IsNormalizationSupported(const TensorInfo& input,
334 const TensorInfo& output,
335 const NormalizationDescriptor& descriptor,
336 Optional<std::string&> reasonIfUnsupported) const
337{
338 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
339}
340
341bool LayerSupportBase::IsOutputSupported(const TensorInfo& output,
342 Optional<std::string&> reasonIfUnsupported) const
343{
344 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
345}
346
347bool LayerSupportBase::IsPadSupported(const TensorInfo& input,
348 const TensorInfo& output,
349 const PadDescriptor& descriptor,
350 Optional<std::string&> reasonIfUnsupported) const
351{
352 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
353}
354
355bool LayerSupportBase::IsPermuteSupported(const TensorInfo& input,
356 const TensorInfo& output,
357 const PermuteDescriptor& descriptor,
358 Optional<std::string&> reasonIfUnsupported) const
359{
360 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
361}
362
363bool LayerSupportBase::IsPooling2dSupported(const TensorInfo& input,
364 const TensorInfo& output,
365 const Pooling2dDescriptor& descriptor,
366 Optional<std::string&> reasonIfUnsupported) const
367{
368 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
369}
370
Matteo Martincigh49124022019-01-11 13:25:59 +0000[diff] [blame]371bool LayerSupportBase::IsPreCompiledSupported(const TensorInfo& input,
372 const PreCompiledDescriptor& descriptor,
373 Optional<std::string&> reasonIfUnsupported) const
374{
375 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
376}
377
Matteo Martincigh0e406ee2019-06-12 15:42:18 +0100[diff] [blame]378bool LayerSupportBase::IsPreluSupported(const TensorInfo& input,
379 const TensorInfo& alpha,
380 const TensorInfo& output,
381 Optional<std::string &> reasonIfUnsupported) const
382{
383 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
384}
385
Derek Lambertia9cca6a2019-03-25 15:41:58 +0000[diff] [blame]386bool LayerSupportBase::IsQuantizeSupported(const armnn::TensorInfo& input,
387 const armnn::TensorInfo& output,
388 armnn::Optional<std::string&> reasonIfUnsupported) const
389{
390 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
391}
392
James Conroyee18dc82019-07-17 11:27:46 +0100[diff] [blame]393bool LayerSupportBase::IsQuantizedLstmSupported(const TensorInfo& input,
394 const TensorInfo& previousCellStateIn,
395 const TensorInfo& previousOutputIn,
396 const TensorInfo& cellStateOut,
397 const TensorInfo& output,
398 const QuantizedLstmInputParamsInfo& paramsInfo,
399 Optional<std::string&> reasonIfUnsupported) const
400{
401 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
402}
403
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]404bool LayerSupportBase::IsReshapeSupported(const TensorInfo& input,
405 const ReshapeDescriptor& descriptor,
406 Optional<std::string&> reasonIfUnsupported) const
407{
408 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
409}
410
411bool LayerSupportBase::IsResizeBilinearSupported(const TensorInfo& input,
Sadik Armaganc625f002018-12-17 11:32:16 +0000[diff] [blame]412 const TensorInfo& output,
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]413 Optional<std::string&> reasonIfUnsupported) const
414{
415 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
416}
417
Teresa Charlina9075df2019-06-27 15:41:57 +0100[diff] [blame]418bool LayerSupportBase::IsResizeSupported(const TensorInfo& input,
419 const TensorInfo& output,
420 const ResizeDescriptor& descriptor,
421 Optional<std::string&> reasonIfUnsupported) const
422{
423 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
424}
425
Matteo Martincigh3d6898c2019-01-15 16:11:44 +0000[diff] [blame]426bool LayerSupportBase::IsRsqrtSupported(const TensorInfo &input,
427 const TensorInfo &output,
428 Optional<std::string &> reasonIfUnsupported) const
429{
430 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
431}
432
Aron Virginas-Tar636ab402019-09-16 14:27:45 +0100[diff] [blame]433bool LayerSupportBase::IsSliceSupported(const TensorInfo& input,
434 const TensorInfo& output,
435 const SliceDescriptor& descriptor,
436 Optional<std::string&> reasonIfUnsupported) const
437{
438 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
439}
440
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]441bool LayerSupportBase::IsSoftmaxSupported(const TensorInfo& input,
442 const TensorInfo& output,
443 const SoftmaxDescriptor& descriptor,
444 Optional<std::string&> reasonIfUnsupported) const
445{
446 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
447}
448
449bool LayerSupportBase::IsSpaceToBatchNdSupported(const TensorInfo& input,
450 const TensorInfo& output,
451 const SpaceToBatchNdDescriptor& descriptor,
452 Optional<std::string&> reasonIfUnsupported) const
453{
454 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
455}
456
Aron Virginas-Tar972af152019-06-11 14:14:03 +0100[diff] [blame]457bool LayerSupportBase::IsSpaceToDepthSupported(const TensorInfo& input,
458 const TensorInfo& output,
459 const SpaceToDepthDescriptor& descriptor,
460 Optional<std::string&> reasonIfUnsupported) const
461{
462 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
463}
464
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]465bool LayerSupportBase::IsSplitterSupported(const TensorInfo& input,
466 const ViewsDescriptor& descriptor,
467 Optional<std::string&> reasonIfUnsupported) const
468{
469 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
470}
471
Narumol Prangnawarat15eb5832019-05-20 15:31:05 +0100[diff] [blame]472bool LayerSupportBase::IsSplitterSupported(const TensorInfo& input,
473 const std::vector<std::reference_wrapper<TensorInfo>>& outputs,
474 const ViewsDescriptor& descriptor,
475 Optional<std::string&> reasonIfUnsupported) const
476{
477 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
478}
479
Matthew Jackson81e601c2019-07-11 12:07:09 +0100[diff] [blame]480bool LayerSupportBase::IsStackSupported(const std::vector<const TensorInfo*>& inputs,
Matthew Jackson2b8c1da2019-07-04 14:59:16 +0100[diff] [blame]481 const TensorInfo& output,
482 const StackDescriptor& descriptor,
483 Optional<std::string&> reasonIfUnsupported) const
484{
485 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
486}
487
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]488bool LayerSupportBase::IsStridedSliceSupported(const TensorInfo& input,
489 const TensorInfo& output,
490 const StridedSliceDescriptor& descriptor,
491 Optional<std::string&> reasonIfUnsupported) const
492{
493 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
494}
495
496bool LayerSupportBase::IsSubtractionSupported(const TensorInfo& input0,
497 const TensorInfo& input1,
498 const TensorInfo& output,
499 Optional<std::string&> reasonIfUnsupported) const
500{
501 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
502}
503
Sadik Armaganeff363d2019-04-05 15:25:46 +0100[diff] [blame]504bool LayerSupportBase::IsSwitchSupported(const TensorInfo& input0,
505 const TensorInfo& input1,
506 const TensorInfo& output0,
507 const TensorInfo& output1,
508 Optional<std::string&> reasonIfUnsupported) const
509{
510 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
511}
512
Aron Virginas-Tar639fb042019-06-20 14:28:19 +0100[diff] [blame]513bool LayerSupportBase::IsTransposeConvolution2dSupported(const TensorInfo& input,
514 const TensorInfo& output,
515 const TransposeConvolution2dDescriptor& descriptor,
516 const TensorInfo& weights,
517 const Optional<TensorInfo>& biases,
518 Optional<std::string&> reasonIfUnsupported) const
519{
520 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
521}
522
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]523} // namespace armnn