Blame - src/backends/cl/ClLayerSupport.hpp - ml/armnn

2023-03-15 15:06:23 +0000

[diff] [blame]

2

David Beck

ecb56cd

2018-09-05 12:52:57 +0100

[diff] [blame]

3

// SPDX-License-Identifier: MIT

telsoa01

4fcda01

2018-03-09 14:13:49 +0000

[diff] [blame]

//

#pragma once

Sadik Armagan

2020-09-10 13:37:32 +0100

[diff] [blame]

7

#include <armnn/backends/IBackendInternal.hpp>

8

Matteo Martincigh

992d6dc

2019-01-10 17:34:20 +0000

[diff] [blame]

9

#include <backendsCommon/LayerSupportBase.hpp>

telsoa01

4fcda01

2018-03-09 14:13:49 +0000

[diff] [blame]

10

11

namespace armnn

12

{

arovir01

4424b0a

2018-10-04 10:46:04 +0100

[diff] [blame]

13

Matteo Martincigh

992d6dc

2019-01-10 17:34:20 +0000

[diff] [blame]

14

class ClLayerSupport : public LayerSupportBase

arovir01

4424b0a

2018-10-04 10:46:04 +0100

[diff] [blame]

15

{

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

16

public:

Sadik Armagan

045f6be

2020-09-10 13:37:32 +0100

[diff] [blame]

17

explicit ClLayerSupport(const IBackendInternal::IBackendSpecificModelContextPtr& modelContextPtr);

ClLayerSupport();

~ClLayerSupport() {}

Cathal Corbett

2021-12-24 12:24:40 +0000

[diff] [blame]

21

bool IsLayerSupported(const LayerType& type,

22

const std::vector<TensorInfo>& infos,

23

const BaseDescriptor& descriptor,

24

const Optional<LstmInputParamsInfo>& lstmParamsInfo,

25

const Optional<QuantizedLstmInputParamsInfo>& quantizedLstmParamsInfo,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

26

Optional<std::string&> reasonIfUnsupported) const;

Cathal Corbett

34b429c

2021-12-24 12:24:40 +0000

[diff] [blame]

27

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

28

bool IsActivationSupported(const TensorInfo& input,

29

const TensorInfo& output,

30

const ActivationDescriptor& descriptor,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

31

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

32

Mike Kelly

2023-03-15 15:06:23 +0000

[diff] [blame]

33

ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use IsLayerSupported instead", "24.02")

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

34

bool IsAdditionSupported(const TensorInfo& input0,

35

const TensorInfo& input1,

36

const TensorInfo& output,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

37

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

38

James Conroy

2dc0572

2019-09-19 17:00:31 +0100

[diff] [blame]

39

bool IsArgMinMaxSupported(const TensorInfo& input,

40

const TensorInfo& output,

41

const ArgMinMaxDescriptor& descriptor,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

42

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

James Conroy

2dc0572

2019-09-19 17:00:31 +0100

[diff] [blame]

43

Teresa Charlin

94916a5

2022-10-19 08:48:07 +0100

[diff] [blame]

44

bool IsBatchMatMulSupported(const TensorInfo& inputX,

45

const TensorInfo& inputY,

46

const TensorInfo& output,

47

const BatchMatMulDescriptor& descriptor,

48

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

49

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

50

bool IsBatchNormalizationSupported(const TensorInfo& input,

51

const TensorInfo& output,

52

const TensorInfo& mean,

53

const TensorInfo& var,

54

const TensorInfo& beta,

55

const TensorInfo& gamma,

56

const BatchNormalizationDescriptor& descriptor,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

57

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

58

Mike Kelly

831faed

2018-11-28 11:52:08 +0000

[diff] [blame]

59

bool IsBatchToSpaceNdSupported(const TensorInfo& input,

60

const TensorInfo& output,

61

const BatchToSpaceNdDescriptor& descriptor,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

62

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

Mike Kelly

831faed

2018-11-28 11:52:08 +0000

[diff] [blame]

63

Sadik Armagan

f40d6d4

2021-04-22 09:12:11 +0100

[diff] [blame]

64

bool IsCastSupported(const TensorInfo& input,

65

const TensorInfo& output,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

66

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

Sadik Armagan

f40d6d4

2021-04-22 09:12:11 +0100

[diff] [blame]

67

Teresa Charlin

1222dbd

2021-09-02 13:58:52 +0100

[diff] [blame]

68

bool IsChannelShuffleSupported(const TensorInfo& input,

69

const TensorInfo& output,

70

const ChannelShuffleDescriptor& descriptor,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

71

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

Teresa Charlin

1222dbd

2021-09-02 13:58:52 +0100

[diff] [blame]

72

Aron Virginas-Tar

77bfb5e

2019-10-16 17:45:38 +0100

[diff] [blame]

73

bool IsComparisonSupported(const TensorInfo& input0,

74

const TensorInfo& input1,

75

const TensorInfo& ouput,

76

const ComparisonDescriptor& descriptor,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

77

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

Aron Virginas-Tar

77bfb5e

2019-10-16 17:45:38 +0100

[diff] [blame]

78

Jim Flynn

906f946

2019-05-10 13:55:21 +0100

[diff] [blame]

79

bool IsConcatSupported(const std::vector<const TensorInfo*> inputs,

80

const TensorInfo& output,

Cathal Corbett

34b429c

2021-12-24 12:24:40 +0000

[diff] [blame]

81

const OriginsDescriptor& descriptor,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

82

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

Jim Flynn

906f946

2019-05-10 13:55:21 +0100

[diff] [blame]

83

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

84

bool IsConstantSupported(const TensorInfo& output,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

85

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

86

87

bool IsConvertFp16ToFp32Supported(const TensorInfo& input,

88

const TensorInfo& output,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

89

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

90

91

bool IsConvertFp32ToFp16Supported(const TensorInfo& input,

92

const TensorInfo& output,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

93

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

94

95

bool IsConvolution2dSupported(const TensorInfo& input,

96

const TensorInfo& output,

97

const Convolution2dDescriptor& descriptor,

98

const TensorInfo& weights,

99

const Optional<TensorInfo>& biases,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

100

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

101

Teresa Charlin

615ad6c

2021-10-26 12:22:20 +0100

[diff] [blame]

102

bool IsConvolution3dSupported(const TensorInfo& input,

103

const TensorInfo& output,

104

const Convolution3dDescriptor& descriptor,

105

const TensorInfo& weights,

106

const Optional<TensorInfo>& biases,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

107

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

Teresa Charlin

615ad6c

2021-10-26 12:22:20 +0100

[diff] [blame]

108

Jim Flynn

983daec

2019-05-29 16:20:16 +0100

[diff] [blame]

109

bool IsDequantizeSupported(const TensorInfo& input,

110

const TensorInfo& output,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

111

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

Jim Flynn

983daec

2019-05-29 16:20:16 +0100

[diff] [blame]

112

Aron Virginas-Tar

b280196

2019-09-30 11:24:53 +0100

[diff] [blame]

113

bool IsDepthToSpaceSupported(const TensorInfo& input,

114

const TensorInfo& output,

115

const DepthToSpaceDescriptor& descriptor,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

116

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

Aron Virginas-Tar

b280196

2019-09-30 11:24:53 +0100

[diff] [blame]

117

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

118

bool IsDepthwiseConvolutionSupported(const TensorInfo& input,

119

const TensorInfo& output,

120

const DepthwiseConvolution2dDescriptor& descriptor,

121

const TensorInfo& weights,

122

const Optional<TensorInfo>& biases,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

123

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

124

Pablo Tello

f0bd683

2019-04-26 17:58:13 +0100

[diff] [blame]

125

bool IsDilatedDepthwiseConvolutionSupported(const TensorInfo& input,

126

const TensorInfo& output,

127

const DepthwiseConvolution2dDescriptor& descriptor,

128

const TensorInfo& weights,

129

const Optional<TensorInfo>& biases,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

130

Optional<std::string&> reason = EmptyOptional()) const;

Pablo Tello

f0bd683

2019-04-26 17:58:13 +0100

[diff] [blame]

131

Mike Kelly

2023-03-15 15:06:23 +0000

[diff] [blame]

132

ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use IsLayerSupported instead", "24.02")

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

133

bool IsDivisionSupported(const TensorInfo& input0,

134

const TensorInfo& input1,

135

const TensorInfo& output,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

136

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

137

josh minor

4a3c610

2020-01-06 16:40:46 -0600

[diff] [blame]

138

bool IsElementwiseUnarySupported(const TensorInfo& input,

Mike Kelly

2023-03-15 15:06:23 +0000

[diff] [blame]

139

const TensorInfo& output,

josh minor

4a3c610

2020-01-06 16:40:46 -0600

[diff] [blame]

140

const ElementwiseUnaryDescriptor& descriptor,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

141

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

josh minor

4a3c610

2020-01-06 16:40:46 -0600

[diff] [blame]

142

Sadik Armagan

66aecb0

2020-06-24 11:42:20 +0100

[diff] [blame]

143

bool IsFillSupported(const TensorInfo& input,

144

const TensorInfo& output,

145

const FillDescriptor& descriptor,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

146

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

Sadik Armagan

66aecb0

2020-06-24 11:42:20 +0100

[diff] [blame]

147

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

148

bool IsFloorSupported(const TensorInfo& input,

149

const TensorInfo& output,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

150

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

151

152

bool IsFullyConnectedSupported(const TensorInfo& input,

153

const TensorInfo& output,

154

const TensorInfo& weights,

155

const TensorInfo& biases,

156

const FullyConnectedDescriptor& descriptor,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

157

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

158

Teresa Charlin

989e2f6

2022-04-27 16:26:11 +0100

[diff] [blame]

159

bool IsGatherNdSupported(const TensorInfo& input0,

160

const TensorInfo& input1,

161

const TensorInfo& output,

162

Optional<std::string&> reasonIfUnsupported) const;

163

Teresa Charlin

9ad2e5b

2020-04-10 22:34:48 +0100

[diff] [blame]

164

bool IsGatherSupported(const TensorInfo& input0,

165

const TensorInfo& input1,

166

const TensorInfo& output,

Teresa Charlin

5266473

2020-06-29 16:27:03 +0100

[diff] [blame]

167

const GatherDescriptor& descriptor,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

168

Optional<std::string&> reasonIfUnsupported) const;

Teresa Charlin

9ad2e5b

2020-04-10 22:34:48 +0100

[diff] [blame]

169

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

170

bool IsInputSupported(const TensorInfo& input,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

171

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

172

Aron Virginas-Tar

8168f40

2019-10-04 13:10:16 +0100

[diff] [blame]

173

bool IsInstanceNormalizationSupported(const TensorInfo& input,

174

const TensorInfo& output,

175

const InstanceNormalizationDescriptor& descriptor,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

176

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

Aron Virginas-Tar

8168f40

2019-10-04 13:10:16 +0100

[diff] [blame]

177

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

178

bool IsL2NormalizationSupported(const TensorInfo& input,

179

const TensorInfo& output,

180

const L2NormalizationDescriptor& descriptor,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

181

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

182

James Conroy

fe3ec94

2020-11-18 14:20:53 +0000

[diff] [blame]

183

bool IsLogicalBinarySupported(const TensorInfo& input0,

184

const TensorInfo& input1,

185

const TensorInfo& output,

186

const LogicalBinaryDescriptor& descriptor,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

187

Optional<std::string&> reasonIfUnsupported) const;

James Conroy

fe3ec94

2020-11-18 14:20:53 +0000

[diff] [blame]

188

Teresa Charlin

8398edc

2020-07-20 14:23:02 +0100

[diff] [blame]

189

bool IsLogSoftmaxSupported(const TensorInfo& input,

190

const TensorInfo& output,

191

const LogSoftmaxDescriptor& descriptor,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

192

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

Teresa Charlin

8398edc

2020-07-20 14:23:02 +0100

[diff] [blame]

193

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

194

bool IsLstmSupported(const TensorInfo& input,

195

const TensorInfo& outputStateIn,

196

const TensorInfo& cellStateIn,

197

const TensorInfo& scratchBuffer,

198

const TensorInfo& outputStateOut,

199

const TensorInfo& cellStateOut,

200

const TensorInfo& output,

201

const LstmDescriptor& descriptor,

Jan Eilers

d01a83c

2019-07-03 18:20:40 +0100

[diff] [blame]

202

const LstmInputParamsInfo& paramsInfo,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

203

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

204

Mike Kelly

2023-03-15 15:06:23 +0000

[diff] [blame]

205

ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use IsLayerSupported instead", "24.02")

keidav01

a959ee5

2018-12-19 10:04:58 +0000

[diff] [blame]

206

bool IsMaximumSupported(const TensorInfo& input0,

207

const TensorInfo& input1,

208

const TensorInfo& output,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

209

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

keidav01

a959ee5

2018-12-19 10:04:58 +0000

[diff] [blame]

210

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

211

bool IsMeanSupported(const TensorInfo& input,

212

const TensorInfo& output,

213

const MeanDescriptor& descriptor,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

214

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

215

Mike Kelly

2023-03-15 15:06:23 +0000

[diff] [blame]

216

ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use IsLayerSupported instead", "24.02")

saoste01

9292aa3

2019-01-08 13:55:59 +0000

[diff] [blame]

217

bool IsMinimumSupported(const TensorInfo& input0,

218

const TensorInfo& input1,

219

const TensorInfo& output,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

220

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

saoste01

9292aa3

2019-01-08 13:55:59 +0000

[diff] [blame]

221

Mike Kelly

2023-03-15 15:06:23 +0000

[diff] [blame]

222

ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use IsLayerSupported instead", "24.02")

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

223

bool IsMultiplicationSupported(const TensorInfo& input0,

224

const TensorInfo& input1,

225

const TensorInfo& output,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

226

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

227

228

bool IsNormalizationSupported(const TensorInfo& input,

229

const TensorInfo& output,

230

const NormalizationDescriptor& descriptor,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

231

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

232

233

bool IsOutputSupported(const TensorInfo& output,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

234

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

235

236

bool IsPadSupported(const TensorInfo& input,

237

const TensorInfo& output,

238

const PadDescriptor& descriptor,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

239

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

240

241

bool IsPermuteSupported(const TensorInfo& input,

242

const TensorInfo& output,

243

const PermuteDescriptor& descriptor,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

244

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

245

246

bool IsPooling2dSupported(const TensorInfo& input,

247

const TensorInfo& output,

248

const Pooling2dDescriptor& descriptor,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

249

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

250

Ryan OShea

bab8fa9

2022-03-09 10:29:02 +0000

[diff] [blame]

251

bool IsPooling3dSupported(const TensorInfo& input,

252

const TensorInfo& output,

253

const Pooling3dDescriptor& descriptor,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

254

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

Ryan OShea

bab8fa9

2022-03-09 10:29:02 +0000

[diff] [blame]

255

Nikhil Raj

91e4c6d

2019-07-05 12:22:58 +0100

[diff] [blame]

256

bool IsPreluSupported(const TensorInfo& input,

257

const TensorInfo& alpha,

258

const TensorInfo& output,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

259

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

Nikhil Raj

91e4c6d

2019-07-05 12:22:58 +0100

[diff] [blame]

260

Ryan OShea

2323af4

2020-05-13 16:36:19 +0100

[diff] [blame]

261

bool IsQLstmSupported(const TensorInfo& input,

262

const TensorInfo& previousOutputIn,

263

const TensorInfo& previousCellStateIn,

264

const TensorInfo& outputStateOut,

265

const TensorInfo& cellStateOut,

266

const TensorInfo& output,

267

const QLstmDescriptor& descriptor,

268

const LstmInputParamsInfo& paramsInfo,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

269

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

Ryan OShea

2323af4

2020-05-13 16:36:19 +0100

[diff] [blame]

270

Ferran Balaguer

737d9ff

2019-08-01 09:58:08 +0100

[diff] [blame]

271

bool IsQuantizedLstmSupported(const TensorInfo& input,

272

const TensorInfo& previousCellStateIn,

273

const TensorInfo& previousOutputIn,

274

const TensorInfo& cellStateOut,

275

const TensorInfo& output,

276

const QuantizedLstmInputParamsInfo& paramsInfo,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

277

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

Ferran Balaguer

737d9ff

2019-08-01 09:58:08 +0100

[diff] [blame]

278

Sadik Armagan

20ec249

2019-05-31 09:09:44 +0100

[diff] [blame]

279

bool IsQuantizeSupported(const TensorInfo& input,

280

const TensorInfo& output,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

281

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

Sadik Armagan

20ec249

2019-05-31 09:09:44 +0100

[diff] [blame]

282

Sadik Armagan

a274748

2021-02-09 10:28:54 +0000

[diff] [blame]

283

bool IsReduceSupported(const TensorInfo& input,

284

const TensorInfo& output,

285

const ReduceDescriptor& descriptor,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

286

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

Sadik Armagan

a274748

2021-02-09 10:28:54 +0000

[diff] [blame]

287

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

288

bool IsReshapeSupported(const TensorInfo& input,

Kevin May

a023c40

2019-12-12 17:28:05 +0000

[diff] [blame]

289

const TensorInfo& output,

Matteo Martincigh

992d6dc

2019-01-10 17:34:20 +0000

[diff] [blame]

290

const ReshapeDescriptor& descriptor,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

291

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

292

Aron Virginas-Tar

169d2f1

2019-07-01 19:01:44 +0100

[diff] [blame]

293

bool IsResizeSupported(const TensorInfo& input,

294

const TensorInfo& output,

295

const ResizeDescriptor& descriptor,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

296

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

Aron Virginas-Tar

169d2f1

2019-07-01 19:01:44 +0100

[diff] [blame]

297

Tianle Cheng

21a9f33

2023-11-09 13:56:53 +0000

[diff] [blame]

298

bool IsReverseV2Supported(const TensorInfo& input,

299

const TensorInfo& axis,

300

const TensorInfo& output,

301

Optional<std::string&> reasonIfUnsupported) const;

302

Aron Virginas-Tar

94c4fef

2019-11-25 15:37:08 +0000

[diff] [blame]

303

bool IsSliceSupported(const TensorInfo& input,

304

const TensorInfo& output,

305

const SliceDescriptor& descriptor,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

306

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

Aron Virginas-Tar

94c4fef

2019-11-25 15:37:08 +0000

[diff] [blame]

307

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

308

bool IsSoftmaxSupported(const TensorInfo& input,

309

const TensorInfo& output,

310

const SoftmaxDescriptor& descriptor,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

311

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

312

Sadik Armagan

f446432

2018-12-20 16:19:12 +0000

[diff] [blame]

313

bool IsSpaceToBatchNdSupported(const TensorInfo& input,

314

const TensorInfo& output,

315

const SpaceToBatchNdDescriptor& descriptor,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

316

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

Sadik Armagan

f446432

2018-12-20 16:19:12 +0000

[diff] [blame]

317

James Conroy

d2aa85e

2019-07-01 17:12:40 +0100

[diff] [blame]

318

bool IsSpaceToDepthSupported(const TensorInfo& input,

319

const TensorInfo& output,

320

const SpaceToDepthDescriptor& descriptor,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

321

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

James Conroy

d2aa85e

2019-07-01 17:12:40 +0100

[diff] [blame]

322

Narumol Prangnawarat

15eb583

2019-05-20 15:31:05 +0100

[diff] [blame]

323

bool IsSplitterSupported(const TensorInfo& input,

324

const std::vector<std::reference_wrapper<TensorInfo>>& outputs,

325

const ViewsDescriptor& descriptor,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

326

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

Narumol Prangnawarat

15eb583

2019-05-20 15:31:05 +0100

[diff] [blame]

327

Matthew Jackson

d516610

2019-07-31 14:06:28 +0100

[diff] [blame]

328

bool IsStackSupported(const std::vector<const TensorInfo*>& inputs,

329

const TensorInfo& output,

330

const StackDescriptor& descriptor,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

331

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

Matthew Jackson

d516610

2019-07-31 14:06:28 +0100

[diff] [blame]

332

keidav01

d74dc91

2018-12-10 18:16:07 +0000

[diff] [blame]

333

bool IsStridedSliceSupported(const TensorInfo& input,

334

const TensorInfo& output,

335

const StridedSliceDescriptor& descriptor,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

336

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

keidav01

d74dc91

2018-12-10 18:16:07 +0000

[diff] [blame]

337

Mike Kelly

2023-03-15 15:06:23 +0000

[diff] [blame]

338

ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use IsLayerSupported instead", "24.02")

arovir01

2018-10-09 11:16:46 +0100

[diff] [blame]

339

bool IsSubtractionSupported(const TensorInfo& input0,

340

const TensorInfo& input1,

341

const TensorInfo& output,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

342

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

Aron Virginas-Tar

7a3e2fe

2019-06-27 18:54:47 +0100

[diff] [blame]

343

344

bool IsTransposeConvolution2dSupported(const TensorInfo& input,

345

const TensorInfo& output,

346

const TransposeConvolution2dDescriptor& descriptor,

347

const TensorInfo& weights,

348

const Optional<TensorInfo>& biases,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

349

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

Mike Kelly

c9ea45a

2020-02-28 18:11:58 +0000

[diff] [blame]

350

Cian McGriskin

3b3dcbf

2023-07-26 11:52:47 +0100

[diff] [blame]

351

bool IsTileSupported(const TensorInfo& input,

352

const TensorInfo& output,

353

const TileDescriptor& descriptor,

354

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

355

Mike Kelly

c9ea45a

2020-02-28 18:11:58 +0000

[diff] [blame]

356

bool IsTransposeSupported(const TensorInfo& input,

357

const TensorInfo& output,

358

const TransposeDescriptor& descriptor,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

359

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;

Mike Kelly

c9ea45a

2020-02-28 18:11:58 +0000

[diff] [blame]

360

Cathal Corbett

2022-03-03 15:14:18 +0000

[diff] [blame]

361

bool IsUnidirectionalSequenceLstmSupported(const TensorInfo& input,

362

const TensorInfo& outputStateIn,

363

const TensorInfo& cellStateIn,

Mike Kelly

1299496

2022-04-21 11:57:09 +0100

[diff] [blame]

364

const TensorInfo& outputStateOut,

365

const TensorInfo& cellStateOut,

Cathal Corbett

2022-03-03 15:14:18 +0000

[diff] [blame]

366

const TensorInfo& output,

Cathal Corbett

2022-03-03 15:14:18 +0000

[diff] [blame]

367

const UnidirectionalSequenceLstmDescriptor& descriptor,

368

const LstmInputParamsInfo& paramsInfo,

Francis Murtagh

2023-07-28 13:01:32 +0100

[diff] [blame]

369

Optional<std::string&> reasonIfUnsupported) const;

Cathal Corbett