Blame - include/armnn/LayerSupport.hpp - ml/armnn

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

[diff] [blame]

1

//

2

David Beck

ecb56cd

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

[diff] [blame]

3

// SPDX-License-Identifier: MIT

telsoa01

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

[diff] [blame]

//

#pragma once

Jim Flynn

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

[diff] [blame]

7

#include <armnn/Deprecated.hpp>

telsoa01

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

[diff] [blame]

8

#include <armnn/DescriptorsFwd.hpp>

David Beck

5eec11d

2018-10-04 15:43:17 +0100

[diff] [blame]

9

#include <armnn/Optional.hpp>

Matthew Bentham

313e1c8

2019-03-25 17:37:47 +0000

[diff] [blame]

10

#include <armnn/Tensor.hpp>

11

#include <armnn/Types.hpp>

Jan Eilers

d01a83c

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

[diff] [blame]

12

#include "LstmParams.hpp"

James Conroy

ee18dc8

2019-07-17 11:27:46 +0100

[diff] [blame]

13

#include "QuantizedLstmParams.hpp"

arovir01

a682410

2018-08-28 17:40:45 +0100

[diff] [blame]

14

telsoa01

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

[diff] [blame]

namespace armnn

{

David Beck

2018-10-16 11:32:20 +0100

[diff] [blame]

18

/// Deprecated in favor of IBackend and ILayerSupport interfaces

David Beck

2018-10-12 10:38:31 +0100

[diff] [blame]

19

bool IsActivationSupported(const BackendId& backend,

telsoa01

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

[diff] [blame]

20

const TensorInfo& input,

telsoa01

2018-08-31 09:22:23 +0100

[diff] [blame]

21

const TensorInfo& output,

telsoa01

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

[diff] [blame]

22

const ActivationDescriptor& descriptor,

23

char* reasonIfUnsupported = nullptr,

24

size_t reasonIfUnsupportedMaxLength = 1024);

25

David Beck

2018-10-16 11:32:20 +0100

[diff] [blame]

26

/// Deprecated in favor of IBackend and ILayerSupport interfaces

David Beck

2018-10-12 10:38:31 +0100

[diff] [blame]

27

bool IsAdditionSupported(const BackendId& backend,

telsoa01

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

[diff] [blame]

28

const TensorInfo& input0,

29

const TensorInfo& input1,

30

const TensorInfo& output,

31

char* reasonIfUnsupported = nullptr,

32

size_t reasonIfUnsupportedMaxLength = 1024);

33

David Beck

2018-10-16 11:32:20 +0100

[diff] [blame]

34

/// Deprecated in favor of IBackend and ILayerSupport interfaces

David Beck

2018-10-12 10:38:31 +0100

[diff] [blame]

35

bool IsBatchNormalizationSupported(const BackendId& backend,

telsoa01

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

[diff] [blame]

36

const TensorInfo& input,

telsoa01

2018-08-31 09:22:23 +0100

[diff] [blame]

37

const TensorInfo& output,

38

const TensorInfo& mean,

39

const TensorInfo& var,

40

const TensorInfo& beta,

41

const TensorInfo& gamma,

telsoa01

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

[diff] [blame]

42

const BatchNormalizationDescriptor& descriptor,

43

char* reasonIfUnsupported = nullptr,

44

size_t reasonIfUnsupportedMaxLength = 1024);

45

David Beck

2018-10-16 11:32:20 +0100

[diff] [blame]

46

/// Deprecated in favor of IBackend and ILayerSupport interfaces

Éanna Ó Catháin

4e1e136

2018-11-12 11:36:34 +0000

[diff] [blame]

47

bool IsBatchToSpaceNdSupported(const BackendId& backend,

48

const TensorInfo& input,

49

const TensorInfo& output,

50

const BatchToSpaceNdDescriptor& descriptor,

51

char* reasonIfUnsupported = nullptr,

52

size_t reasonIfUnsupportedMaxLength = 1024);

53

54

/// Deprecated in favor of IBackend and ILayerSupport interfaces

Jim Flynn

906f946

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

[diff] [blame]

55

bool IsConcatSupported(const BackendId& backend,

56

const std::vector<const TensorInfo*> inputs,

57

const TensorInfo& output,

58

const OriginsDescriptor& descriptor,

59

char* reasonIfUnsupported = nullptr,

60

size_t reasonIfUnsupportedMaxLength = 1024);

61

62

/// Deprecated in favor of IBackend and ILayerSupport interfaces

David Beck

2018-10-12 10:38:31 +0100

[diff] [blame]

63

bool IsConstantSupported(const BackendId& backend,

telsoa01

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

[diff] [blame]

64

const TensorInfo& output,

65

char* reasonIfUnsupported = nullptr,

66

size_t reasonIfUnsupportedMaxLength = 1024);

67

David Beck

2018-10-16 11:32:20 +0100

[diff] [blame]

68

/// Deprecated in favor of IBackend and ILayerSupport interfaces

David Beck

2018-10-12 10:38:31 +0100

[diff] [blame]

69

bool IsConvertFp16ToFp32Supported(const BackendId& backend,

telsoa01

2018-08-31 09:22:23 +0100

[diff] [blame]

70

const TensorInfo& input,

71

const TensorInfo& output,

72

char* reasonIfUnsupported = nullptr,

73

size_t reasonIfUnsupportedMaxLength = 1024);

74

David Beck

2018-10-16 11:32:20 +0100

[diff] [blame]

75

/// Deprecated in favor of IBackend and ILayerSupport interfaces

David Beck

2018-10-12 10:38:31 +0100

[diff] [blame]

76

bool IsConvertFp32ToFp16Supported(const BackendId& backend,

telsoa01

2018-08-31 09:22:23 +0100

[diff] [blame]

77

const TensorInfo& input,

78

const TensorInfo& output,

79

char* reasonIfUnsupported = nullptr,

80

size_t reasonIfUnsupportedMaxLength = 1024);

81

David Beck

2018-10-16 11:32:20 +0100

[diff] [blame]

82

/// Deprecated in favor of IBackend and ILayerSupport interfaces

David Beck

2018-10-12 10:38:31 +0100

[diff] [blame]

83

bool IsConvolution2dSupported(const BackendId& backend,

telsoa01

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

[diff] [blame]

84

const TensorInfo& input,

surmeh01

3537c2c

2018-05-18 16:31:43 +0100

[diff] [blame]

85

const TensorInfo& output,

telsoa01

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

[diff] [blame]

86

const Convolution2dDescriptor& descriptor,

87

const TensorInfo& weights,

David Beck

5eec11d

2018-10-04 15:43:17 +0100

[diff] [blame]

88

const Optional<TensorInfo>& biases,

telsoa01

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

[diff] [blame]

89

char* reasonIfUnsupported = nullptr,

90

size_t reasonIfUnsupportedMaxLength = 1024);

91

David Beck

2018-10-16 11:32:20 +0100

[diff] [blame]

92

/// Deprecated in favor of IBackend and ILayerSupport interfaces

Nattapat Chaimanowong

a9a1cf1

2018-12-03 16:06:49 +0000

[diff] [blame]

93

bool IsDebugSupported(const BackendId& backend,

94

const TensorInfo& input,

95

const TensorInfo& output,

96

char* reasonIfUnsupported = nullptr,

97

size_t reasonIfUnsupportedMaxLength = 1024);

98

99

/// Deprecated in favor of IBackend and ILayerSupport interfaces

David Beck

2018-10-12 10:38:31 +0100

[diff] [blame]

100

bool IsDepthwiseConvolutionSupported(const BackendId& backend,

telsoa01

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

[diff] [blame]

101

const TensorInfo& input,

telsoa01

2018-08-31 09:22:23 +0100

[diff] [blame]

102

const TensorInfo& output,

telsoa01

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

[diff] [blame]

103

const DepthwiseConvolution2dDescriptor& descriptor,

104

const TensorInfo& weights,

David Beck

5eec11d

2018-10-04 15:43:17 +0100

[diff] [blame]

105

const Optional<TensorInfo>& biases,

telsoa01

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

[diff] [blame]

106

char* reasonIfUnsupported = nullptr,

107

size_t reasonIfUnsupportedMaxLength = 1024);

108

David Beck

2018-10-16 11:32:20 +0100

[diff] [blame]

109

/// Deprecated in favor of IBackend and ILayerSupport interfaces

Nattapat Chaimanowong

e4294fd

2019-03-28 09:56:53 +0000

[diff] [blame]

110

bool IsDequantizeSupported(const BackendId& backend,

111

const TensorInfo& input,

112

const TensorInfo& output,

113

char* reasonIfUnsupported = nullptr,

114

size_t reasonIfUnsupportedMaxLength = 1024);

115

116

/// Deprecated in favor of IBackend and ILayerSupport interfaces

David Beck

2018-10-12 10:38:31 +0100

[diff] [blame]

117

bool IsDivisionSupported(const BackendId& backend,

Francis Murtagh

e7a86a4

2018-08-29 12:42:10 +0100

[diff] [blame]

118

const TensorInfo& input0,

119

const TensorInfo& input1,

120

const TensorInfo& output,

121

char* reasonIfUnsupported = nullptr,

122

size_t reasonIfUnsupportedMaxLength = 1024);

123

David Beck

2018-10-16 11:32:20 +0100

[diff] [blame]

124

/// Deprecated in favor of IBackend and ILayerSupport interfaces

Matteo Martincigh

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

[diff] [blame]

125

bool IsEqualSupported(const BackendId& backend,

126

const TensorInfo& input0,

127

const TensorInfo& input1,

128

const TensorInfo& output,

129

char* reasonIfUnsupported = nullptr,

130

size_t reasonIfUnsupportedMaxLength = 1024);

David Beck

c2044fe

2018-09-05 15:00:38 +0100

[diff] [blame]

131

David Beck

2018-10-16 11:32:20 +0100

[diff] [blame]

132

/// Deprecated in favor of IBackend and ILayerSupport interfaces

Matteo Martincigh

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

[diff] [blame]

133

bool IsFakeQuantizationSupported(const BackendId& backend,

134

const TensorInfo& input,

135

const FakeQuantizationDescriptor& descriptor,

136

char* reasonIfUnsupported = nullptr,

137

size_t reasonIfUnsupportedMaxLength = 1024);

138

139

/// Deprecated in favor of IBackend and ILayerSupport interfaces

140

bool IsFloorSupported(const BackendId& backend,

telsoa01

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

[diff] [blame]

141

const TensorInfo& input,

Matteo Martincigh

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

[diff] [blame]

142

const TensorInfo& output,

telsoa01

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

[diff] [blame]

143

char* reasonIfUnsupported = nullptr,

144

size_t reasonIfUnsupportedMaxLength = 1024);

145

David Beck

2018-10-16 11:32:20 +0100

[diff] [blame]

146

/// Deprecated in favor of IBackend and ILayerSupport interfaces

David Beck

2018-10-12 10:38:31 +0100

[diff] [blame]

147

bool IsFullyConnectedSupported(const BackendId& backend,

telsoa01

2018-08-31 09:22:23 +0100

[diff] [blame]

148

const TensorInfo& input,

149

const TensorInfo& output,

150

const TensorInfo& weights,

151

const TensorInfo& biases,

152

const FullyConnectedDescriptor& descriptor,

telsoa01

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

[diff] [blame]

153

char* reasonIfUnsupported = nullptr,

154

size_t reasonIfUnsupportedMaxLength = 1024);

155

David Beck

2018-10-16 11:32:20 +0100

[diff] [blame]

156

/// Deprecated in favor of IBackend and ILayerSupport interfaces

Matteo Martincigh

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

[diff] [blame]

157

bool IsGreaterSupported(const BackendId& backend,

158

const TensorInfo& input0,

159

const TensorInfo& input1,

160

const TensorInfo& output,

161

char* reasonIfUnsupported = nullptr,

162

size_t reasonIfUnsupportedMaxLength = 1024);

163

164

/// Deprecated in favor of IBackend and ILayerSupport interfaces

165

bool IsInputSupported(const BackendId& backend,

166

const TensorInfo& input,

167

char* reasonIfUnsupported = nullptr,

168

size_t reasonIfUnsupportedMaxLength = 1024);

169

170

/// Deprecated in favor of IBackend and ILayerSupport interfaces

David Beck

2018-10-12 10:38:31 +0100

[diff] [blame]

171

bool IsL2NormalizationSupported(const BackendId& backend,

telsoa01

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

[diff] [blame]

172

const TensorInfo& input,

telsoa01

2018-08-31 09:22:23 +0100

[diff] [blame]

173

const TensorInfo& output,

Matteo Martincigh

bcd3c85

2018-09-28 14:14:12 +0100

[diff] [blame]

174

const L2NormalizationDescriptor& descriptor,

telsoa01

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

[diff] [blame]

175

char* reasonIfUnsupported = nullptr,

176

size_t reasonIfUnsupportedMaxLength = 1024);

177

David Beck

2018-10-16 11:32:20 +0100

[diff] [blame]

178

/// Deprecated in favor of IBackend and ILayerSupport interfaces

David Beck

2018-10-12 10:38:31 +0100

[diff] [blame]

179

bool IsLstmSupported(const BackendId& backend, const TensorInfo& input, const TensorInfo& outputStateIn,

telsoa01

2018-08-31 09:22:23 +0100

[diff] [blame]

180

const TensorInfo& cellStateIn, const TensorInfo& scratchBuffer,

181

const TensorInfo& outputStateOut, const TensorInfo& cellStateOut,

182

const TensorInfo& output, const LstmDescriptor& descriptor,

Jan Eilers

d01a83c

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

[diff] [blame]

183

const LstmInputParamsInfo& paramsInfo, char* reasonIfUnsupported = nullptr,

telsoa01

2018-08-31 09:22:23 +0100

[diff] [blame]

184

size_t reasonIfUnsupportedMaxLength = 1024);

185

David Beck

2018-10-16 11:32:20 +0100

[diff] [blame]

186

/// Deprecated in favor of IBackend and ILayerSupport interfaces

Nattapat Chaimanowong

5a4304a

2018-11-28 10:44:37 +0000

[diff] [blame]

187

bool IsMaximumSupported(const BackendId& backend,

188

const TensorInfo& input0,

189

const TensorInfo& input1,

190

const TensorInfo& output,

191

char* reasonIfUnSupported = nullptr,

192

size_t reasonIfUnSupportedMaxLength = 0);

193

194

/// Deprecated in favor of IBackend and ILayerSupport interfaces

Matteo Martincigh

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

[diff] [blame]

195

bool IsMeanSupported(const BackendId& backend,

196

const TensorInfo& input,

197

const TensorInfo& output,

198

const MeanDescriptor& descriptor,

199

char* reasonIfUnsupported = nullptr,

200

size_t reasonIfUnsupportedMaxLength = 1024);

201

202

/// Deprecated in favor of IBackend and ILayerSupport interfaces

203

bool IsMemCopySupported(const BackendId& backend,

204

const TensorInfo& input,

205

const TensorInfo& output,

206

char* reasonIfUnsupported = nullptr,

207

size_t reasonIfUnsupportedMaxLength = 1024);

208

209

/// Deprecated in favor of IBackend and ILayerSupport interfaces

Nattapat Chaimanowong

1f88630

2019-04-05 13:37:19 +0100

[diff] [blame]

210

bool IsMergeSupported(const BackendId& backend,

211

const TensorInfo& input0,

212

const TensorInfo& input1,

213

const TensorInfo& output,

214

char* reasonIfUnsupported = nullptr,

215

size_t reasonIfUnsupportedMaxLength = 1024);

216

217

/// Deprecated in favor of IBackend and ILayerSupport interfaces

Jim Flynn

906f946

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

[diff] [blame]

218

ARMNN_DEPRECATED_MSG("Use IsConcatSupported instead")

David Beck

2018-10-12 10:38:31 +0100

[diff] [blame]

219

bool IsMergerSupported(const BackendId& backend,

telsoa01

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

[diff] [blame]

220

const std::vector<const TensorInfo*> inputs,

Nikhil Raj

8599a41

2018-11-19 14:51:07 +0000

[diff] [blame]

221

const TensorInfo& output,

telsoa01

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

[diff] [blame]

222

const OriginsDescriptor& descriptor,

223

char* reasonIfUnsupported = nullptr,

224

size_t reasonIfUnsupportedMaxLength = 1024);

225

David Beck

2018-10-16 11:32:20 +0100

[diff] [blame]

226

/// Deprecated in favor of IBackend and ILayerSupport interfaces

Matteo Martincigh

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

[diff] [blame]

227

bool IsMinimumSupported(const BackendId& backend,

228

const TensorInfo& input0,

229

const TensorInfo& input1,

230

const TensorInfo& output,

231

char* reasonIfUnsupported = nullptr,

232

size_t reasonIfUnsupportedMaxLength = 1024);

233

234

/// Deprecated in favor of IBackend and ILayerSupport interfaces

David Beck

2018-10-12 10:38:31 +0100

[diff] [blame]

235

bool IsMultiplicationSupported(const BackendId& backend,

telsoa01

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

[diff] [blame]

236

const TensorInfo& input0,

237

const TensorInfo& input1,

telsoa01

2018-08-31 09:22:23 +0100

[diff] [blame]

238

const TensorInfo& output,

telsoa01

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

[diff] [blame]

239

char* reasonIfUnsupported = nullptr,

240

size_t reasonIfUnsupportedMaxLength = 1024);

241

David Beck

2018-10-16 11:32:20 +0100

[diff] [blame]

242

/// Deprecated in favor of IBackend and ILayerSupport interfaces

David Beck

2018-10-12 10:38:31 +0100

[diff] [blame]

243

bool IsNormalizationSupported(const BackendId& backend,

telsoa01

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

[diff] [blame]

244

const TensorInfo& input,

245

const TensorInfo& output,

246

const NormalizationDescriptor& descriptor,

247

char* reasonIfUnsupported = nullptr,

248

size_t reasonIfUnsupportedMaxLength = 1024);

249

David Beck

2018-10-16 11:32:20 +0100

[diff] [blame]

250

/// Deprecated in favor of IBackend and ILayerSupport interfaces

David Beck

2018-10-12 10:38:31 +0100

[diff] [blame]

251

bool IsOutputSupported(const BackendId& backend,

telsoa01

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

[diff] [blame]

252

const TensorInfo& output,

253

char* reasonIfUnsupported = nullptr,

254

size_t reasonIfUnsupportedMaxLength = 1024);

255

David Beck

2018-10-16 11:32:20 +0100

[diff] [blame]

256

/// Deprecated in favor of IBackend and ILayerSupport interfaces

Matteo Martincigh

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

[diff] [blame]

257

bool IsPadSupported(const BackendId& backend,

258

const TensorInfo& input,

259

const TensorInfo& output,

260

const PadDescriptor& descriptor,

261

char* reasonIfUnsupported = nullptr,

262

size_t reasonIfUnsupportedMaxLength = 1024);

263

264

/// Deprecated in favor of IBackend and ILayerSupport interfaces

David Beck

2018-10-12 10:38:31 +0100

[diff] [blame]

265

bool IsPermuteSupported(const BackendId& backend,

telsoa01

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

[diff] [blame]

266

const TensorInfo& input,

267

const TensorInfo& output,

268

const PermuteDescriptor& descriptor,

269

char* reasonIfUnsupported = nullptr,

270

size_t reasonIfUnsupportedMaxLength = 1024);

271

David Beck

2018-10-16 11:32:20 +0100

[diff] [blame]

272

/// Deprecated in favor of IBackend and ILayerSupport interfaces

Matteo Martincigh

4912402

2019-01-11 13:25:59 +0000

[diff] [blame]

273

bool IsPreCompiledSupported(const BackendId& backend,

274

const TensorInfo& input,

275

char* reasonIfUnsupported = nullptr,

276

size_t reasonIfUnsupportedMaxLength = 1024);

277

278

/// Deprecated in favor of IBackend and ILayerSupport interfaces

Matteo Martincigh

0e406ee

2019-06-12 15:42:18 +0100

[diff] [blame]

279

bool IsPreluSupported(const BackendId& backend,

280

const TensorInfo& input,

281

const TensorInfo& alpha,

282

const TensorInfo& output,

283

char* reasonIfUnsupported = nullptr,

284

size_t reasonIfUnsupportedMaxLength = 1024);

285

286

/// Deprecated in favor of IBackend and ILayerSupport interfaces

David Beck

2018-10-12 10:38:31 +0100

[diff] [blame]

287

bool IsPooling2dSupported(const BackendId& backend,

telsoa01

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

[diff] [blame]

288

const TensorInfo& input,

289

const TensorInfo& output,

290

const Pooling2dDescriptor& descriptor,

291

char* reasonIfUnsupported = nullptr,

292

size_t reasonIfUnsupportedMaxLength = 1024);

293

David Beck

2018-10-16 11:32:20 +0100

[diff] [blame]

294

/// Deprecated in favor of IBackend and ILayerSupport interfaces

James Conroy

ee18dc8

2019-07-17 11:27:46 +0100

[diff] [blame]

295

bool IsQuantizedLstmSupported(const BackendId& backend,

296

const TensorInfo& input,

297

const TensorInfo& previousCellStateIn,

298

const TensorInfo& previousOutputIn,

299

const TensorInfo& cellStateOut,

300

const TensorInfo& output,

301

const QuantizedLstmInputParamsInfo& paramsInfo,

302

char* reasonIfUnsupported = nullptr,

303

size_t reasonIfUnsupportedMaxLength = 1024);

304

305

/// Deprecated in favor of IBackend and ILayerSupport interfaces

Sadik Armagan

0c3ea5b

2021-02-03 09:29:30 +0000

[diff] [blame]

306

bool IsReduceSupported(const BackendId& backend,

307

const TensorInfo& input,

308

const TensorInfo& output,

309

const ReduceDescriptor& descriptor,

310

char* reasonIfUnsupported = nullptr,

311

size_t reasonIfUnsupportedMaxLength = 1024);

312

313

/// Deprecated in favor of IBackend and ILayerSupport interfaces

Matteo Martincigh

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

[diff] [blame]

314

bool IsReshapeSupported(const BackendId& backend,

315

const TensorInfo& input,

316

const ReshapeDescriptor& descriptor,

317

char* reasonIfUnsupported = nullptr,

318

size_t reasonIfUnsupportedMaxLength = 1024);

319

320

/// Deprecated in favor of IBackend and ILayerSupport interfaces

Aron Virginas-Tar

169d2f1

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

[diff] [blame]

321

ARMNN_DEPRECATED_MSG("Use IsResizeSupported instead")

David Beck

2018-10-12 10:38:31 +0100

[diff] [blame]

322

bool IsResizeBilinearSupported(const BackendId& backend,

telsoa01

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

[diff] [blame]

323

const TensorInfo& input,

Sadik Armagan

c625f00

2018-12-17 11:32:16 +0000

[diff] [blame]

324

const TensorInfo& output,

telsoa01

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

[diff] [blame]

325

char* reasonIfUnsupported = nullptr,

326

size_t reasonIfUnsupportedMaxLength = 1024);

327

David Beck

2018-10-16 11:32:20 +0100

[diff] [blame]

328

/// Deprecated in favor of IBackend and ILayerSupport interfaces

Aron Virginas-Tar

169d2f1

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

[diff] [blame]

329

bool IsResizeSupported(const BackendId& backend,

330

const TensorInfo& input,

331

const TensorInfo& output,

332

const ResizeDescriptor& descriptor,

333

char* reasonIfUnsupported = nullptr,

334

size_t reasonIfUnsupportedMaxLength = 1024);

335

336

/// Deprecated in favor of IBackend and ILayerSupport interfaces

Matteo Martincigh

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

[diff] [blame]

337

bool IsRsqrtSupported(const BackendId& backend,

338

const TensorInfo& input,

339

const TensorInfo& output,

340

char* reasonIfUnsupported = nullptr,

341

size_t reasonIfUnsupportedMaxLength = 1024);

342

343

/// Deprecated in favor of IBackend and ILayerSupport interfaces

David Beck

2018-10-12 10:38:31 +0100

[diff] [blame]

344

bool IsSoftmaxSupported(const BackendId& backend,

telsoa01

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

[diff] [blame]

345

const TensorInfo& input,

telsoa01

2018-08-31 09:22:23 +0100

[diff] [blame]

346

const TensorInfo& output,

telsoa01

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

[diff] [blame]

347

const SoftmaxDescriptor& descriptor,

348

char* reasonIfUnsupported = nullptr,

349

size_t reasonIfUnsupportedMaxLength = 1024);

350

David Beck

2018-10-16 11:32:20 +0100

[diff] [blame]

351

/// Deprecated in favor of IBackend and ILayerSupport interfaces

Nattapat Chaimanowong

207ef9a

2018-11-02 10:57:25 +0000

[diff] [blame]

352

bool IsSpaceToBatchNdSupported(const BackendId& backend,

353

const TensorInfo& input,

354

const TensorInfo& output,

355

const SpaceToBatchNdDescriptor& descriptor,

356

char* reasonIfUnsupported = nullptr,

357

size_t reasonIfUnsupportedMaxLength = 1024);

358

Aron Virginas-Tar

972af15

2019-06-11 14:14:03 +0100

[diff] [blame]

359

/// Deprecated in favor of IBackend and ILayerSupport interfaces

360

bool IsSpaceToDepthSupported(const BackendId& backend,

361

const TensorInfo& input,

362

const TensorInfo& output,

363

const SpaceToDepthDescriptor& descriptor,

364

char* reasonIfUnsupported = nullptr,

365

size_t reasonIfUnsupportedMaxLength = 1024);

366

Narumol Prangnawarat

15eb583

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

[diff] [blame]

367

ARMNN_DEPRECATED_MSG("Use IsSplitterSupported with outputs instead")

368

bool IsSplitterSupported(const BackendId& backend,

369

const TensorInfo& input,

370

const ViewsDescriptor& descriptor,

371

char* reasonIfUnsupported = nullptr,

372

size_t reasonIfUnsupportedMaxLength = 1024);

373

Nattapat Chaimanowong

207ef9a

2018-11-02 10:57:25 +0000

[diff] [blame]

374

/// Deprecated in favor of IBackend and ILayerSupport interfaces

David Beck

2018-10-12 10:38:31 +0100

[diff] [blame]

375

bool IsSplitterSupported(const BackendId& backend,

telsoa01

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

[diff] [blame]

376

const TensorInfo& input,

Narumol Prangnawarat

15eb583

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

[diff] [blame]

377

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

telsoa01

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

[diff] [blame]

378

const ViewsDescriptor& descriptor,

379

char* reasonIfUnsupported = nullptr,

380

size_t reasonIfUnsupportedMaxLength = 1024);

381

David Beck

2018-10-16 11:32:20 +0100

[diff] [blame]

382

/// Deprecated in favor of IBackend and ILayerSupport interfaces

Matthew Jackson

2b8c1da

2019-07-04 14:59:16 +0100

[diff] [blame]

383

bool IsStackSupported(const BackendId& backend,

384

const std::vector<const TensorInfo*> inputs,

385

const TensorInfo& output,

386

const StackDescriptor& descriptor,

387

char* reasonIfUnsupported = nullptr,

388

size_t reasonIfUnsupportedMaxLength = 1024);

389

390

/// Deprecated in favor of IBackend and ILayerSupport interfaces

Conor Kennedy

430b5d8

2018-11-14 15:28:28 +0000

[diff] [blame]

391

bool IsStridedSliceSupported(const BackendId& backend,

392

const TensorInfo& input,

393

const TensorInfo& output,

394

const StridedSliceDescriptor& descriptor,

395

char* reasonIfUnsupported = nullptr,

396

size_t reasonIfUnsupportedMaxLength = 1024);

397

kevmay01

9053969

2018-11-29 08:40:19 +0000

[diff] [blame]

398

/// Deprecated in favor of IBackend and ILayerSupport interfaces

Matteo Martincigh

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

[diff] [blame]

399

bool IsSubtractionSupported(const BackendId& backend,

400

const TensorInfo& input0,

401

const TensorInfo& input1,

402

const TensorInfo& output,

403

char* reasonIfUnsupported = nullptr,

404

size_t reasonIfUnsupportedMaxLength = 1024);

Sadik Armagan

eff363d

2019-04-05 15:25:46 +0100

[diff] [blame]

405

406

/// Deprecated in favor of IBackend and ILayerSupport interfaces

407

bool IsSwitchSupported(const BackendId& backend,

408

const TensorInfo& input0,

409

const TensorInfo& input1,

410

const TensorInfo& output0,

411

const TensorInfo& output1,

412

char* reasonIfUnsupported = nullptr,

413

size_t reasonIfUnsupportedMaxLength = 1024);

Aron Virginas-Tar

639fb04

2019-06-20 14:28:19 +0100

[diff] [blame]

414

415

/// Deprecated in favor of IBackend and ILayerSupport interfaces

416

bool IsTransposeConvolution2dSupported(const BackendId& backend,

417

const TensorInfo& input,

418

const TensorInfo& output,

419

const TransposeConvolution2dDescriptor& descriptor,

420

const TensorInfo& weights,

421

const Optional<TensorInfo>& biases,

422

char* reasonIfUnsupported = nullptr,

423

size_t reasonIfUnsupportedMaxLength = 1024);

Sadik Armagan

0c3ea5b

2021-02-03 09:29:30 +0000

[diff] [blame]

424

telsoa01