Gitiles
Code Review Sign In
review.mlplatform.org / ml / armnn / f982deaefbe5fe5814487b27f7099829839b8666 / . / src / backends / backendsCommon / LayerSupportBase.cpp
blob: 7d5555ce68342fead9403a99f26c5ae1edf3a61b [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
Aron Virginas-Tarf982dea2019-10-11 14:07:53 +0100[diff] [blame^]253bool LayerSupportBase::IsLogSoftmaxSupported(const TensorInfo& input,
254 const TensorInfo& output,
255 const LogSoftmaxDescriptor& descriptor,
256 Optional<std::string&> reasonIfUnsupported) const
257{
258 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
259}
260
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]261bool LayerSupportBase::IsLstmSupported(const TensorInfo& input,
262 const TensorInfo& outputStateIn,
263 const TensorInfo& cellStateIn,
264 const TensorInfo& scratchBuffer,
265 const TensorInfo& outputStateOut,
266 const TensorInfo& cellStateOut,
267 const TensorInfo& output,
268 const LstmDescriptor& descriptor,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]269 const LstmInputParamsInfo& paramsInfo,
270 Optional<std::string&> reasonIfUnsupported) const
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]271{
272 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
273}
274
275bool LayerSupportBase::IsMaximumSupported(const TensorInfo& input0,
276 const TensorInfo& input1,
277 const TensorInfo& output,
278 Optional<std::string&> reasonIfUnsupported) const
279{
280 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
281}
282
283bool LayerSupportBase::IsMeanSupported(const TensorInfo& input,
284 const TensorInfo& output,
285 const MeanDescriptor& descriptor,
286 Optional<std::string&> reasonIfUnsupported) const
287{
288 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
289}
290
291bool LayerSupportBase::IsMemCopySupported(const armnn::TensorInfo& input,
292 const armnn::TensorInfo& output,
293 armnn::Optional<std::string &> reasonIfUnsupported) const
294{
Derek Lambertif674aa02019-08-01 15:56:25 +0100[diff] [blame]295 boost::ignore_unused(input);
296 boost::ignore_unused(output);
297 return true;
298}
299
300bool LayerSupportBase::IsMemImportSupported(const armnn::TensorInfo& input,
301 const armnn::TensorInfo& output,
302 armnn::Optional<std::string &> reasonIfUnsupported) const
303{
304 boost::ignore_unused(input);
305 boost::ignore_unused(output);
306 return true;
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]307}
308
Nattapat Chaimanowong1f886302019-04-05 13:37:19 +0100[diff] [blame]309bool LayerSupportBase::IsMergeSupported(const TensorInfo& input0,
310 const TensorInfo& input1,
311 const TensorInfo& output,
312 Optional<std::string&> reasonIfUnsupported) const
313{
314 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
315}
316
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]317bool LayerSupportBase::IsMergerSupported(const std::vector<const TensorInfo*> inputs,
318 const TensorInfo& output,
319 const OriginsDescriptor& descriptor,
320 Optional<std::string&> reasonIfUnsupported) const
321{
Jim Flynne242f2d2019-05-22 14:24:13 +0100[diff] [blame]322 return IsConcatSupported(inputs, output, descriptor, reasonIfUnsupported);
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]323}
324
325bool LayerSupportBase::IsMinimumSupported(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::IsMultiplicationSupported(const TensorInfo& input0,
334 const TensorInfo& input1,
335 const TensorInfo& output,
336 Optional<std::string&> reasonIfUnsupported) const
337{
338 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
339}
340
341bool LayerSupportBase::IsNormalizationSupported(const TensorInfo& input,
342 const TensorInfo& output,
343 const NormalizationDescriptor& descriptor,
344 Optional<std::string&> reasonIfUnsupported) const
345{
346 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
347}
348
349bool LayerSupportBase::IsOutputSupported(const TensorInfo& output,
350 Optional<std::string&> reasonIfUnsupported) const
351{
352 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
353}
354
355bool LayerSupportBase::IsPadSupported(const TensorInfo& input,
356 const TensorInfo& output,
357 const PadDescriptor& descriptor,
358 Optional<std::string&> reasonIfUnsupported) const
359{
360 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
361}
362
363bool LayerSupportBase::IsPermuteSupported(const TensorInfo& input,
364 const TensorInfo& output,
365 const PermuteDescriptor& descriptor,
366 Optional<std::string&> reasonIfUnsupported) const
367{
368 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
369}
370
371bool LayerSupportBase::IsPooling2dSupported(const TensorInfo& input,
372 const TensorInfo& output,
373 const Pooling2dDescriptor& descriptor,
374 Optional<std::string&> reasonIfUnsupported) const
375{
376 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
377}
378
Matteo Martincigh49124022019-01-11 13:25:59 +0000[diff] [blame]379bool LayerSupportBase::IsPreCompiledSupported(const TensorInfo& input,
380 const PreCompiledDescriptor& descriptor,
381 Optional<std::string&> reasonIfUnsupported) const
382{
383 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
384}
385
Matteo Martincigh0e406ee2019-06-12 15:42:18 +0100[diff] [blame]386bool LayerSupportBase::IsPreluSupported(const TensorInfo& input,
387 const TensorInfo& alpha,
388 const TensorInfo& output,
389 Optional<std::string &> reasonIfUnsupported) const
390{
391 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
392}
393
Derek Lambertia9cca6a2019-03-25 15:41:58 +0000[diff] [blame]394bool LayerSupportBase::IsQuantizeSupported(const armnn::TensorInfo& input,
395 const armnn::TensorInfo& output,
396 armnn::Optional<std::string&> reasonIfUnsupported) const
397{
398 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
399}
400
James Conroyee18dc82019-07-17 11:27:46 +0100[diff] [blame]401bool LayerSupportBase::IsQuantizedLstmSupported(const TensorInfo& input,
402 const TensorInfo& previousCellStateIn,
403 const TensorInfo& previousOutputIn,
404 const TensorInfo& cellStateOut,
405 const TensorInfo& output,
406 const QuantizedLstmInputParamsInfo& paramsInfo,
407 Optional<std::string&> reasonIfUnsupported) const
408{
409 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
410}
411
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]412bool LayerSupportBase::IsReshapeSupported(const TensorInfo& input,
413 const ReshapeDescriptor& descriptor,
414 Optional<std::string&> reasonIfUnsupported) const
415{
416 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
417}
418
419bool LayerSupportBase::IsResizeBilinearSupported(const TensorInfo& input,
Sadik Armaganc625f002018-12-17 11:32:16 +0000[diff] [blame]420 const TensorInfo& output,
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]421 Optional<std::string&> reasonIfUnsupported) const
422{
423 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
424}
425
Teresa Charlina9075df2019-06-27 15:41:57 +0100[diff] [blame]426bool LayerSupportBase::IsResizeSupported(const TensorInfo& input,
427 const TensorInfo& output,
428 const ResizeDescriptor& descriptor,
429 Optional<std::string&> reasonIfUnsupported) const
430{
431 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
432}
433
Matteo Martincigh3d6898c2019-01-15 16:11:44 +0000[diff] [blame]434bool LayerSupportBase::IsRsqrtSupported(const TensorInfo &input,
435 const TensorInfo &output,
436 Optional<std::string &> reasonIfUnsupported) const
437{
438 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
439}
440
Aron Virginas-Tar636ab402019-09-16 14:27:45 +0100[diff] [blame]441bool LayerSupportBase::IsSliceSupported(const TensorInfo& input,
442 const TensorInfo& output,
443 const SliceDescriptor& descriptor,
444 Optional<std::string&> reasonIfUnsupported) const
445{
446 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
447}
448
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]449bool LayerSupportBase::IsSoftmaxSupported(const TensorInfo& input,
450 const TensorInfo& output,
451 const SoftmaxDescriptor& descriptor,
452 Optional<std::string&> reasonIfUnsupported) const
453{
454 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
455}
456
457bool LayerSupportBase::IsSpaceToBatchNdSupported(const TensorInfo& input,
458 const TensorInfo& output,
459 const SpaceToBatchNdDescriptor& descriptor,
460 Optional<std::string&> reasonIfUnsupported) const
461{
462 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
463}
464
Aron Virginas-Tar972af152019-06-11 14:14:03 +0100[diff] [blame]465bool LayerSupportBase::IsSpaceToDepthSupported(const TensorInfo& input,
466 const TensorInfo& output,
467 const SpaceToDepthDescriptor& descriptor,
468 Optional<std::string&> reasonIfUnsupported) const
469{
470 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
471}
472
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]473bool LayerSupportBase::IsSplitterSupported(const TensorInfo& input,
474 const ViewsDescriptor& descriptor,
475 Optional<std::string&> reasonIfUnsupported) const
476{
477 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
478}
479
Narumol Prangnawarat15eb5832019-05-20 15:31:05 +0100[diff] [blame]480bool LayerSupportBase::IsSplitterSupported(const TensorInfo& input,
481 const std::vector<std::reference_wrapper<TensorInfo>>& outputs,
482 const ViewsDescriptor& descriptor,
483 Optional<std::string&> reasonIfUnsupported) const
484{
485 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
486}
487
Matthew Jackson81e601c2019-07-11 12:07:09 +0100[diff] [blame]488bool LayerSupportBase::IsStackSupported(const std::vector<const TensorInfo*>& inputs,
Matthew Jackson2b8c1da2019-07-04 14:59:16 +0100[diff] [blame]489 const TensorInfo& output,
490 const StackDescriptor& descriptor,
491 Optional<std::string&> reasonIfUnsupported) const
492{
493 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
494}
495
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]496bool LayerSupportBase::IsStridedSliceSupported(const TensorInfo& input,
497 const TensorInfo& output,
498 const StridedSliceDescriptor& descriptor,
499 Optional<std::string&> reasonIfUnsupported) const
500{
501 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
502}
503
504bool LayerSupportBase::IsSubtractionSupported(const TensorInfo& input0,
505 const TensorInfo& input1,
506 const TensorInfo& output,
507 Optional<std::string&> reasonIfUnsupported) const
508{
509 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
510}
511
Sadik Armaganeff363d2019-04-05 15:25:46 +0100[diff] [blame]512bool LayerSupportBase::IsSwitchSupported(const TensorInfo& input0,
513 const TensorInfo& input1,
514 const TensorInfo& output0,
515 const TensorInfo& output1,
516 Optional<std::string&> reasonIfUnsupported) const
517{
518 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
519}
520
Aron Virginas-Tar639fb042019-06-20 14:28:19 +0100[diff] [blame]521bool LayerSupportBase::IsTransposeConvolution2dSupported(const TensorInfo& input,
522 const TensorInfo& output,
523 const TransposeConvolution2dDescriptor& descriptor,
524 const TensorInfo& weights,
525 const Optional<TensorInfo>& biases,
526 Optional<std::string&> reasonIfUnsupported) const
527{
528 return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
529}
530
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]531} // namespace armnn