Blame - src/backends/backendsCommon/LayerSupportBase.cpp - ml/armnn

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

[diff] [blame]

1

//

Teresa Charlin

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

[diff] [blame]

2

Matteo Martincigh

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

[diff] [blame]

3

// SPDX-License-Identifier: MIT

4

//

5

josh minor

4a3c610

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

[diff] [blame]

6

#include <armnn/Deprecated.hpp>

7

#include <armnn/Descriptors.hpp>

Matteo Martincigh

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

[diff] [blame]

8

#include <armnn/Exceptions.hpp>

josh minor

4a3c610

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

[diff] [blame]

9

#include <armnn/Types.hpp>

Matteo Martincigh

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

[diff] [blame]

10

Matteo Martincigh

e5b8eb9

2019-11-28 15:45:42 +0000

[diff] [blame]

11

#include <backendsCommon/LayerSupportBase.hpp>

12

Jan Eilers

8eb2560

2020-03-09 12:13:48 +0000

[diff] [blame]

13

#include <armnn/utility/IgnoreUnused.hpp>

Derek Lamberti

2019-08-01 15:56:25 +0100

[diff] [blame]

14

Matteo Martincigh

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

[diff] [blame]

namespace

{

bool DefaultLayerSupport(const char* func,

19

const char* file,

20

unsigned int line,

21

armnn::Optional<std::string&> reasonIfUnsupported)

22

{

23

// NOTE: We only need to return the reason if the optional parameter is not empty

24

if (reasonIfUnsupported)

25

{

26

std::stringstream message;

27

message << func << " is not implemented [" << file << ":" << line << "]";

28

29

reasonIfUnsupported.value() = message.str();

}

return false;

}

} // anonymous namespace

namespace armnn

{

Teresa Charlin

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

[diff] [blame]

40

bool LayerSupportBase::IsActivationSupported(const TensorInfo&, // input

41

const TensorInfo&, //output

42

const ActivationDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

43

Optional<std::string&> reasonIfUnsupported) const

44

{

45

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

46

}

47

Teresa Charlin

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

[diff] [blame]

48

bool LayerSupportBase::IsAdditionSupported(const TensorInfo&, // input0

49

const TensorInfo&, // input1

50

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

51

Optional<std::string&> reasonIfUnsupported) const

52

{

53

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

54

}

55

Teresa Charlin

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

[diff] [blame]

56

bool LayerSupportBase::IsArgMinMaxSupported(const armnn::TensorInfo&, // input

57

const armnn::TensorInfo&, // output

58

const armnn::ArgMinMaxDescriptor&, // descriptor

Nikhil Raj

ee391d5

2019-09-05 17:50:44 +0100

[diff] [blame]

59

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

60

{

61

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

62

}

63

Teresa Charlin

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

[diff] [blame]

64

bool LayerSupportBase::IsBatchNormalizationSupported(const TensorInfo&, //input

65

const TensorInfo&, // output

66

const TensorInfo&, //mean

67

const TensorInfo&, //var

68

const TensorInfo&, //beta

69

const TensorInfo&, //gamma

70

const BatchNormalizationDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

71

Optional<std::string&> reasonIfUnsupported) const

72

{

73

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

74

}

75

Teresa Charlin

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

[diff] [blame]

76

bool LayerSupportBase::IsBatchToSpaceNdSupported(const TensorInfo&, // input

77

const TensorInfo&, // output

78

const BatchToSpaceNdDescriptor&, //descriptor

Matteo Martincigh

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

[diff] [blame]

79

Optional<std::string&> reasonIfUnsupported) const

80

{

81

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

82

}

83

mathad01

b392e98

2021-04-07 12:07:30 +0100

[diff] [blame]

84

bool LayerSupportBase::IsCastSupported(const TensorInfo&, //input

85

const TensorInfo&, //output

86

Optional<std::string &> reasonIfUnsupported) const

87

{

88

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

89

}

90

Simon Obute

51f6777

2021-09-03 15:50:13 +0100

[diff] [blame]

91

bool LayerSupportBase::IsChannelShuffleSupported(const TensorInfo&, //input

92

const TensorInfo&, //output

93

const ChannelShuffleDescriptor&, //descriptor

94

Optional<std::string &> reasonIfUnsupported) const

95

{

96

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

97

}

98

Teresa Charlin

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

[diff] [blame]

99

bool LayerSupportBase::IsComparisonSupported(const TensorInfo&, // input0

100

const TensorInfo&, // input1

101

const TensorInfo&, // output

102

const ComparisonDescriptor&, // descriptor

Aron Virginas-Tar

77bfb5e

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

[diff] [blame]

103

Optional<std::string&> reasonIfUnsupported) const

104

{

105

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

106

}

107

Teresa Charlin

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

[diff] [blame]

108

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

109

const TensorInfo&, // output

110

const OriginsDescriptor&, // descriptor

Jim Flynn

906f946

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

[diff] [blame]

111

Optional<std::string&> reasonIfUnsupported) const

112

{

Jim Flynn

e242f2d

2019-05-22 14:24:13 +0100

[diff] [blame]

113

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

Jim Flynn

906f946

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

[diff] [blame]

114

}

115

Teresa Charlin

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

[diff] [blame]

116

bool LayerSupportBase::IsConstantSupported(const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

117

Optional<std::string&> reasonIfUnsupported) const

118

{

119

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

120

}

121

Teresa Charlin

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

[diff] [blame]

122

bool LayerSupportBase::IsConvertBf16ToFp32Supported(const TensorInfo&, // input

123

const TensorInfo&, // output

Narumol Prangnawarat

7ddbbae

2020-03-13 10:26:05 +0000

[diff] [blame]

124

Optional<std::string&> reasonIfUnsupported) const

125

{

126

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

127

}

128

Teresa Charlin

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

[diff] [blame]

129

bool LayerSupportBase::IsConvertFp16ToFp32Supported(const TensorInfo&, // input

130

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

131

Optional<std::string&> reasonIfUnsupported) const

132

{

133

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

134

}

135

Teresa Charlin

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

[diff] [blame]

136

bool LayerSupportBase::IsConvertFp32ToBf16Supported(const TensorInfo&, // input

137

const TensorInfo&, // output

Narumol Prangnawarat

ea54a01

2020-03-16 16:36:10 +0000

[diff] [blame]

138

Optional<std::string&> reasonIfUnsupported) const

139

{

140

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

}

Teresa Charlin

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

[diff] [blame]

144

bool LayerSupportBase::IsConvertFp32ToFp16Supported(const TensorInfo&, // input

145

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

146

Optional<std::string&> reasonIfUnsupported) const

147

{

148

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

149

}

150

Teresa Charlin

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

[diff] [blame]

151

bool LayerSupportBase::IsConvolution2dSupported(const TensorInfo&, // input

152

const TensorInfo&, // output

153

const Convolution2dDescriptor&, // descriptor

154

const TensorInfo&, // weights

155

const Optional<TensorInfo>&, // biases

Matteo Martincigh

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

[diff] [blame]

156

Optional<std::string&> reasonIfUnsupported) const

157

{

158

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

159

}

160

Matthew Sloyan

b63a311

2021-09-08 13:05:51 +0100

[diff] [blame]

161

bool LayerSupportBase::IsConvolution3dSupported(const TensorInfo&, // input

162

const TensorInfo&, // output

163

const Convolution3dDescriptor&, // descriptor

164

const TensorInfo&, // weights

165

const Optional<TensorInfo>&, // biases

166

Optional<std::string&> reasonIfUnsupported) const

167

{

168

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

169

}

170

Teresa Charlin

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

[diff] [blame]

171

bool LayerSupportBase::IsDebugSupported(const TensorInfo&, // input

172

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

173

Optional<std::string&> reasonIfUnsupported) const

174

{

175

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

176

}

177

Teresa Charlin

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

[diff] [blame]

178

bool LayerSupportBase::IsDepthToSpaceSupported(const TensorInfo&, // input

179

const TensorInfo&, // output

180

const DepthToSpaceDescriptor&, // descriptor

Aron Virginas-Tar

dd6247f

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

[diff] [blame]

181

Optional<std::string&> reasonIfUnsupported) const

182

{

183

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

184

}

185

Teresa Charlin

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

[diff] [blame]

186

bool LayerSupportBase::IsDepthwiseConvolutionSupported(const TensorInfo&, //input

187

const TensorInfo&, //output

188

const DepthwiseConvolution2dDescriptor&, // descriptor

189

const TensorInfo&, // weights

190

const Optional<TensorInfo>&, // biases

Matteo Martincigh

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

[diff] [blame]

191

Optional<std::string&> reasonIfUnsupported) const

192

{

193

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

194

}

195

Teresa Charlin

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

[diff] [blame]

196

bool LayerSupportBase::IsDequantizeSupported(const TensorInfo&, // input

197

const TensorInfo&, // output

Nattapat Chaimanowong

e4294fd

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

[diff] [blame]

198

Optional<std::string&> reasonIfUnsupported) const

199

{

200

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

201

}

202

Teresa Charlin

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

[diff] [blame]

203

bool LayerSupportBase::IsDetectionPostProcessSupported(const TensorInfo&, // boxEncodings

204

const TensorInfo&, // scores

205

const TensorInfo&, // anchors

206

const TensorInfo&, // detectionBoxes

207

const TensorInfo&, // detectionClasses

208

const TensorInfo&, // detectionScores

209

const TensorInfo&, // numDetections

210

const DetectionPostProcessDescriptor&, //descriptor

Derek Lamberti

6a5e5e8

2019-12-05 14:41:20 +0000

[diff] [blame]

211

Optional<std::string&> reasonIfUnsupported) const

Narumol Prangnawarat

94dd5d8

2019-01-23 18:06:26 +0000

[diff] [blame]

212

{

213

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

214

}

215

Teresa Charlin

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

[diff] [blame]

216

bool LayerSupportBase::IsDilatedDepthwiseConvolutionSupported(const TensorInfo&, // input

217

const TensorInfo&, // output

218

const DepthwiseConvolution2dDescriptor&, // descriptor

219

const TensorInfo&,// weights

220

const Optional<TensorInfo>&, // biases

Matteo Martincigh

eac246d

2019-05-14 09:11:03 +0100

[diff] [blame]

221

Optional<std::string&> reasonIfUnsupported) const

222

{

223

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

224

}

225

Teresa Charlin

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

[diff] [blame]

226

bool LayerSupportBase::IsDivisionSupported(const TensorInfo&, // input0

227

const TensorInfo&, // input1

228

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

229

Optional<std::string&> reasonIfUnsupported) const

230

{

231

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

232

}

233

Jan Eilers

1b2654f

2021-09-24 15:45:46 +0100

[diff] [blame]

234

bool LayerSupportBase::IsElementwiseUnarySupported(const TensorInfo&, // input

235

const TensorInfo&, // output

236

const ElementwiseUnaryDescriptor&, // descriptor

josh minor

4a3c610

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

[diff] [blame]

237

Optional<std::string&> reasonIfUnsupported) const

238

{

Matteo Martincigh

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

[diff] [blame]

239

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

240

}

241

Teresa Charlin

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

[diff] [blame]

242

bool LayerSupportBase::IsFakeQuantizationSupported(const TensorInfo&, // input

243

const FakeQuantizationDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

244

Optional<std::string&> reasonIfUnsupported) const

245

{

246

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

247

}

248

Teresa Charlin

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

[diff] [blame]

249

bool LayerSupportBase::IsFillSupported(const TensorInfo&, // input

250

const TensorInfo&, // output

251

const FillDescriptor&, // descriptor

Ryan OShea

ec6c680

2020-06-05 17:17:06 +0100

[diff] [blame]

252

Optional<std::string&> reasonIfUnsupported) const

253

{

254

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

255

}

256

Teresa Charlin

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

[diff] [blame]

257

bool LayerSupportBase::IsFloorSupported(const TensorInfo&, // input

258

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

259

Optional<std::string&> reasonIfUnsupported) const

260

{

261

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

262

}

263

Teresa Charlin

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

[diff] [blame]

264

bool LayerSupportBase::IsFullyConnectedSupported(const TensorInfo&, // input

265

const TensorInfo&, // output

266

const TensorInfo&, // weights

267

const TensorInfo&, // biases

268

const FullyConnectedDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

269

Optional<std::string&> reasonIfUnsupported) const

270

{

271

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

272

}

273

Teresa Charlin

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

[diff] [blame]

274

bool LayerSupportBase::IsGatherSupported(const armnn::TensorInfo&, // input0

275

const armnn::TensorInfo&, // input1

276

const armnn::TensorInfo&, // output

Teresa Charlin

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

[diff] [blame]

277

const GatherDescriptor&, // descriptor

278

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

279

{

280

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

281

}

282

Teresa Charlin

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

[diff] [blame]

283

bool LayerSupportBase::IsInputSupported(const TensorInfo&, // input

Matteo Martincigh

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

[diff] [blame]

284

Optional<std::string&> reasonIfUnsupported) const

285

{

286

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

287

}

288

Teresa Charlin

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

[diff] [blame]

289

bool LayerSupportBase::IsInstanceNormalizationSupported(const TensorInfo&, // input

290

const TensorInfo&, // output

291

const InstanceNormalizationDescriptor&, // descriptor

Kevin May

ce5045a

2019-10-02 14:07:47 +0100

[diff] [blame]

292

Optional<std::string&> reasonIfUnsupported) const

293

{

294

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

295

}

296

Teresa Charlin

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

[diff] [blame]

297

bool LayerSupportBase::IsL2NormalizationSupported(const TensorInfo&, // input

James Conroy

aba90cd

2020-11-06 16:28:18 +0000

[diff] [blame]

298

const TensorInfo&, // output

Teresa Charlin

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

[diff] [blame]

299

const L2NormalizationDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

300

Optional<std::string&> reasonIfUnsupported) const

301

{

302

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

303

}

304

James Conroy

aba90cd

2020-11-06 16:28:18 +0000

[diff] [blame]

305

bool LayerSupportBase::IsLogicalBinarySupported(const TensorInfo&, // input0

306

const TensorInfo&, // input1

307

const TensorInfo&, // output

308

const LogicalBinaryDescriptor&, // descriptor

309

Optional<std::string&> reasonIfUnsupported) const

310

{

311

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

312

}

313

314

bool LayerSupportBase::IsLogicalUnarySupported(const TensorInfo&, // input

315

const TensorInfo&, // output

316

const ElementwiseUnaryDescriptor&, // descriptor

317

Optional<std::string&> reasonIfUnsupported) const

318

{

319

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

320

}

321

Teresa Charlin

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

[diff] [blame]

322

bool LayerSupportBase::IsLogSoftmaxSupported(const TensorInfo&, // input

323

const TensorInfo&, // output

324

const LogSoftmaxDescriptor&, // descriptor

Aron Virginas-Tar

f982dea

2019-10-11 14:07:53 +0100

[diff] [blame]

325

Optional<std::string&> reasonIfUnsupported) const

326

{

327

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

328

}

329

Teresa Charlin

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

[diff] [blame]

330

bool LayerSupportBase::IsLstmSupported(const TensorInfo&, // input

331

const TensorInfo&, // outputStateIn

332

const TensorInfo&, // cellStateIn

333

const TensorInfo&, // scratchBuffer

334

const TensorInfo&, // outputStateOut

335

const TensorInfo&, // cellStateOut

336

const TensorInfo&, // output

337

const LstmDescriptor&, // descriptor

338

const LstmInputParamsInfo&, // paramsInfo

Jan Eilers

d01a83c

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

[diff] [blame]

339

Optional<std::string&> reasonIfUnsupported) const

Matteo Martincigh

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

[diff] [blame]

340

{

341

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

342

}

343

Teresa Charlin

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

[diff] [blame]

344

bool LayerSupportBase::IsMaximumSupported(const TensorInfo&, // input0

345

const TensorInfo&, // input1

346

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

347

Optional<std::string&> reasonIfUnsupported) const

348

{

349

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

350

}

351

Teresa Charlin

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

[diff] [blame]

352

bool LayerSupportBase::IsMeanSupported(const TensorInfo&, // input

353

const TensorInfo&, // output

354

const MeanDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

355

Optional<std::string&> reasonIfUnsupported) const

356

{

357

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

358

}

359

Teresa Charlin

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

[diff] [blame]

360

bool LayerSupportBase::IsMemCopySupported(const armnn::TensorInfo&, // input

361

const armnn::TensorInfo&, // output

362

armnn::Optional<std::string &> ) const // reasonIfUnsupported

Matteo Martincigh

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

[diff] [blame]

363

{

Derek Lamberti

2019-08-01 15:56:25 +0100

[diff] [blame]

return true;

}

Teresa Charlin

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

[diff] [blame]

367

bool LayerSupportBase::IsMemImportSupported(const armnn::TensorInfo&, // input

368

const armnn::TensorInfo&, // output

369

armnn::Optional<std::string &> ) const // reasonIfUnsupported

Derek Lamberti

2019-08-01 15:56:25 +0100

[diff] [blame]

370

{

Derek Lamberti

2019-08-01 15:56:25 +0100

[diff] [blame]

371

return true;

Matteo Martincigh

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

[diff] [blame]

372

}

373

Teresa Charlin

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

[diff] [blame]

374

bool LayerSupportBase::IsMergeSupported(const TensorInfo&, // input0

375

const TensorInfo&, // input1

376

const TensorInfo&, // output

Nattapat Chaimanowong

1f88630

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

[diff] [blame]

377

Optional<std::string&> reasonIfUnsupported) const

378

{

379

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

380

}

381

Teresa Charlin

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

[diff] [blame]

382

bool LayerSupportBase::IsMinimumSupported(const TensorInfo&, // input0

383

const TensorInfo&, // input1

384

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

385

Optional<std::string&> reasonIfUnsupported) const

386

{

387

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

388

}

389

Teresa Charlin

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

[diff] [blame]

390

bool LayerSupportBase::IsMultiplicationSupported(const TensorInfo&, // input0

391

const TensorInfo&, // input1

392

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

393

Optional<std::string&> reasonIfUnsupported) const

394

{

395

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

396

}

397

Teresa Charlin

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

[diff] [blame]

398

bool LayerSupportBase::IsNormalizationSupported(const TensorInfo&, // input

399

const TensorInfo&, // output

400

const NormalizationDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

401

Optional<std::string&> reasonIfUnsupported) const

402

{

403

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

404

}

405

Teresa Charlin

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

[diff] [blame]

406

bool LayerSupportBase::IsOutputSupported(const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

407

Optional<std::string&> reasonIfUnsupported) const

408

{

409

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

410

}

411

Teresa Charlin

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

[diff] [blame]

412

bool LayerSupportBase::IsPadSupported(const TensorInfo&, // input

413

const TensorInfo&, // output

414

const PadDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

415

Optional<std::string&> reasonIfUnsupported) const

416

{

417

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

418

}

419

Teresa Charlin

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

[diff] [blame]

420

bool LayerSupportBase::IsPermuteSupported(const TensorInfo&, // input

421

const TensorInfo&, // output

422

const PermuteDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

423

Optional<std::string&> reasonIfUnsupported) const

424

{

425

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

426

}

427

Teresa Charlin

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

[diff] [blame]

428

bool LayerSupportBase::IsPooling2dSupported(const TensorInfo&, // input

429

const TensorInfo&, // output

430

const Pooling2dDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

431

Optional<std::string&> reasonIfUnsupported) const

432

{

433

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

434

}

435

Teresa Charlin

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

[diff] [blame]

436

bool LayerSupportBase::IsPreCompiledSupported(const TensorInfo&, // input

437

const PreCompiledDescriptor&, // descriptor

Matteo Martincigh

4912402

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

[diff] [blame]

438

Optional<std::string&> reasonIfUnsupported) const

439

{

440

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

441

}

442

Teresa Charlin

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

[diff] [blame]

443

bool LayerSupportBase::IsPreluSupported(const TensorInfo&, // input

444

const TensorInfo&, // alpha

445

const TensorInfo&, // output

Matteo Martincigh

0e406ee

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

[diff] [blame]

446

Optional<std::string &> reasonIfUnsupported) const

447

{

448

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

449

}

450

Teresa Charlin

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

[diff] [blame]

451

bool LayerSupportBase::IsQuantizeSupported(const armnn::TensorInfo&, // input

452

const armnn::TensorInfo&, // output

Derek Lamberti

a9cca6a

2019-03-25 15:41:58 +0000

[diff] [blame]

453

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

454

{

455

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

456

}

457

Teresa Charlin

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

[diff] [blame]

458

bool LayerSupportBase::IsQLstmSupported(const TensorInfo&, // input

459

const TensorInfo&, // previousOutputIn

460

const TensorInfo&, // previousCellStateIn

461

const TensorInfo&, // outputStateOut

462

const TensorInfo&, // cellStateOut

463

const TensorInfo&, // output

464

const QLstmDescriptor&, // descriptor

465

const LstmInputParamsInfo&, // paramsInfo

James Conroy

586a9aa

2020-03-20 08:49:33 +0000

[diff] [blame]

466

Optional<std::string&> reasonIfUnsupported) const

467

{

468

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

469

}

470

Teresa Charlin

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

[diff] [blame]

471

bool LayerSupportBase::IsQuantizedLstmSupported(const TensorInfo&, // input

472

const TensorInfo&, // previousCellStateIn

473

const TensorInfo&, // previousOutputIn

474

const TensorInfo&, // cellStateOut

475

const TensorInfo&, // output

476

const QuantizedLstmInputParamsInfo&, // paramsInfo

James Conroy

ee18dc8

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

[diff] [blame]

477

Optional<std::string&> reasonIfUnsupported) const

478

{

479

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

480

}

481

Finn Williams

2605b23

2020-06-10 15:53:46 +0100

[diff] [blame]

482

bool LayerSupportBase::IsRankSupported(const TensorInfo&, // input

483

const TensorInfo&, // output

484

Optional<std::string&> reasonIfUnsupported) const

485

{

486

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

487

}

488

Sadik Armagan

0c3ea5b

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

[diff] [blame]

489

bool LayerSupportBase::IsReduceSupported(const TensorInfo& /*input*/,

490

const TensorInfo& /*output*/,

491

const ReduceDescriptor& /*descriptor*/,

492

Optional<std::string&> reasonIfUnsupported) const

493

{

494

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

495

}

496

Teresa Charlin

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

[diff] [blame]

497

bool LayerSupportBase::IsReshapeSupported(const TensorInfo&, // input

498

const TensorInfo&, // output

499

const ReshapeDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

500

Optional<std::string&> reasonIfUnsupported) const

501

{

502

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

503

}

504

Teresa Charlin

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

[diff] [blame]

505

bool LayerSupportBase::IsResizeSupported(const TensorInfo&, // input

506

const TensorInfo&, // output

507

const ResizeDescriptor&, // descriptor

Teresa Charlin

a9075df

2019-06-27 15:41:57 +0100

[diff] [blame]

508

Optional<std::string&> reasonIfUnsupported) const

509

{

510

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

511

}

512

Keith Davis

3ae3f97

2021-05-21 16:33:48 +0100

[diff] [blame]

513

bool LayerSupportBase::IsShapeSupported(const TensorInfo&, // input

514

const TensorInfo&, // output

515

Optional<std::string&> reasonIfUnsupported) const

516

{

517

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

518

}

519

Teresa Charlin

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

[diff] [blame]

520

bool LayerSupportBase::IsSliceSupported(const TensorInfo&, // input

521

const TensorInfo&, // output

522

const SliceDescriptor&, // descriptor

Aron Virginas-Tar

636ab40

2019-09-16 14:27:45 +0100

[diff] [blame]

523

Optional<std::string&> reasonIfUnsupported) const

524

{

525

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

526

}

527

Teresa Charlin

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

[diff] [blame]

528

bool LayerSupportBase::IsSoftmaxSupported(const TensorInfo&, // input

529

const TensorInfo&, // output

530

const SoftmaxDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

531

Optional<std::string&> reasonIfUnsupported) const

532

{

533

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

534

}

Derek Lamberti

901ea11

2019-12-10 22:07:09 +0000

[diff] [blame]

535

/**/

Teresa Charlin

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

[diff] [blame]

536

bool LayerSupportBase::IsSpaceToBatchNdSupported(const TensorInfo&, // input

537

const TensorInfo&, // output

538

const SpaceToBatchNdDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

539

Optional<std::string&> reasonIfUnsupported) const

540

{

541

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

542

}

543

Teresa Charlin

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

[diff] [blame]

544

bool LayerSupportBase::IsSpaceToDepthSupported(const TensorInfo&, // input

545

const TensorInfo&, // output

546

const SpaceToDepthDescriptor&, // descriptor

Aron Virginas-Tar

972af15

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

[diff] [blame]

547

Optional<std::string&> reasonIfUnsupported) const

548

{

549

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

550

}

551

Teresa Charlin

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

[diff] [blame]

552

bool LayerSupportBase::IsSplitterSupported(const TensorInfo&, // input

Teresa Charlin

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

[diff] [blame]

553

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

554

const ViewsDescriptor&, // descriptor

Narumol Prangnawarat

15eb583

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

[diff] [blame]

555

Optional<std::string&> reasonIfUnsupported) const

556

{

557

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

558

}

559

Teresa Charlin

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

[diff] [blame]

560

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

561

const TensorInfo&, // output

562

const StackDescriptor&, // descriptor

Matthew Jackson

2b8c1da

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

[diff] [blame]

563

Optional<std::string&> reasonIfUnsupported) const

564

{

565

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

566

}

567

Teresa Charlin

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

[diff] [blame]

568

bool LayerSupportBase::IsStandInSupported(const std::vector<const TensorInfo*>&, // inputs

569

const std::vector<const TensorInfo*>&, // outputs

570

const StandInDescriptor&, // descriptor

Derek Lamberti

013c390

2019-10-21 10:46:16 +0100

[diff] [blame]

571

Optional<std::string&> reasonIfUnsupported) const

572

{

573

if (reasonIfUnsupported)

574

{

575

std::stringstream message;

576

message << "StandIn layer is not executable via backends";

577

578

reasonIfUnsupported.value() = message.str();

}

return false;

}

Teresa Charlin

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

[diff] [blame]

584

bool LayerSupportBase::IsStridedSliceSupported(const TensorInfo&, // input

585

const TensorInfo&, // output

586

const StridedSliceDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

587

Optional<std::string&> reasonIfUnsupported) const

588

{

589

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

590

}

591

Teresa Charlin

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

[diff] [blame]

592

bool LayerSupportBase::IsSubtractionSupported(const TensorInfo&, // input0

593

const TensorInfo&, // input1

594

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

595

Optional<std::string&> reasonIfUnsupported) const

596

{

597

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

598

}

599

Teresa Charlin

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

[diff] [blame]

600

bool LayerSupportBase::IsSwitchSupported(const TensorInfo&, // input0

601

const TensorInfo&, // input1

602

const TensorInfo&, // output0

603

const TensorInfo&, // output1

Sadik Armagan

eff363d

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

[diff] [blame]

604

Optional<std::string&> reasonIfUnsupported) const

605

{

606

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

607

}

608

Teresa Charlin

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

[diff] [blame]

609

bool LayerSupportBase::IsTransposeConvolution2dSupported(const TensorInfo&, // input

610

const TensorInfo&, // output

611

const TransposeConvolution2dDescriptor&, // descriptor

612

const TensorInfo&, // weights

613

const Optional<TensorInfo>&, // biases

Aron Virginas-Tar

639fb04

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

[diff] [blame]

614

Optional<std::string&> reasonIfUnsupported) const

615

{

616

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

Teresa Charlin

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

[diff] [blame]

617

}

Aron Virginas-Tar

639fb04

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

[diff] [blame]

618

Teresa Charlin

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

[diff] [blame]

619

bool LayerSupportBase::IsTransposeSupported(const TensorInfo&, // input

620

const TensorInfo&, // output

621

const TransposeDescriptor&, // descriptor

Mike Kelly

c9ea45a

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

[diff] [blame]

622

Optional<std::string&> reasonIfUnsupported) const

623

{

624

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

625

}

626

Narumol Prangnawarat

8ed39ae

2021-07-15 16:16:25 +0100

[diff] [blame]

627

bool LayerSupportBase::IsUnidirectionalSequenceLstmSupported(const TensorInfo&, // input

628

const TensorInfo&, // outputStateIn

629

const TensorInfo&, // cellStateIn

630

const TensorInfo&, // output

631

const Optional<TensorInfo>&, // hiddenStateOut

632

const Optional<TensorInfo>&, // cellStateOut

633

const LstmDescriptor&, // descriptor

634

const LstmInputParamsInfo&, // paramsInfo

635

Optional<std::string&> reasonIfUnsupported) const

636

{

637

return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);

638

}

639

Matteo Martincigh