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::IsAbsSupported(const TensorInfo&, // input

41

const TensorInfo&, // output

Kevin May

868eb14

2019-09-04 17:29:31 +0100

[diff] [blame]

42

Optional<std::string &> reasonIfUnsupported) const

43

{

44

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

45

}

46

Teresa Charlin

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

[diff] [blame]

47

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

48

const TensorInfo&, //output

49

const ActivationDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

50

Optional<std::string&> reasonIfUnsupported) const

51

{

52

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

53

}

54

Teresa Charlin

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

[diff] [blame]

55

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

56

const TensorInfo&, // input1

57

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

58

Optional<std::string&> reasonIfUnsupported) const

59

{

60

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

61

}

62

Teresa Charlin

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

[diff] [blame]

63

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

64

const armnn::TensorInfo&, // output

65

const armnn::ArgMinMaxDescriptor&, // descriptor

Nikhil Raj

ee391d5

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

[diff] [blame]

66

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

67

{

68

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

69

}

70

Teresa Charlin

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

[diff] [blame]

71

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

72

const TensorInfo&, // output

73

const TensorInfo&, //mean

74

const TensorInfo&, //var

75

const TensorInfo&, //beta

76

const TensorInfo&, //gamma

77

const BatchNormalizationDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

78

Optional<std::string&> reasonIfUnsupported) const

79

{

80

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

81

}

82

Teresa Charlin

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

[diff] [blame]

83

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

84

const TensorInfo&, // output

85

const BatchToSpaceNdDescriptor&, //descriptor

Matteo Martincigh

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

[diff] [blame]

86

Optional<std::string&> reasonIfUnsupported) const

87

{

88

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

89

}

90

mathad01

b392e98

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

[diff] [blame]

91

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

92

const TensorInfo&, //output

93

Optional<std::string &> reasonIfUnsupported) const

94

{

95

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

96

}

97

Simon Obute

51f6777

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

[diff] [blame]

98

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

99

const TensorInfo&, //output

100

const ChannelShuffleDescriptor&, //descriptor

101

Optional<std::string &> reasonIfUnsupported) const

102

{

103

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

104

}

105

Teresa Charlin

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

[diff] [blame]

106

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

107

const TensorInfo&, // input1

108

const TensorInfo&, // output

109

const ComparisonDescriptor&, // descriptor

Aron Virginas-Tar

77bfb5e

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

[diff] [blame]

110

Optional<std::string&> reasonIfUnsupported) const

111

{

112

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

113

}

114

Teresa Charlin

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

[diff] [blame]

115

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

116

const TensorInfo&, // output

117

const OriginsDescriptor&, // descriptor

Jim Flynn

906f946

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

[diff] [blame]

118

Optional<std::string&> reasonIfUnsupported) const

119

{

Jim Flynn

e242f2d

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

[diff] [blame]

120

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

Jim Flynn

906f946

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

[diff] [blame]

121

}

122

Teresa Charlin

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

[diff] [blame]

123

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

Matteo Martincigh

2019-01-10 17:34:20 +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::IsConvertBf16ToFp32Supported(const TensorInfo&, // input

130

const TensorInfo&, // output

Narumol Prangnawarat

7ddbbae

2020-03-13 10:26:05 +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::IsConvertFp16ToFp32Supported(const TensorInfo&, // input

137

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

138

Optional<std::string&> reasonIfUnsupported) const

139

{

140

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

141

}

142

Teresa Charlin

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

[diff] [blame]

143

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

144

const TensorInfo&, // output

Narumol Prangnawarat

ea54a01

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

[diff] [blame]

145

Optional<std::string&> reasonIfUnsupported) const

146

{

147

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

}

Teresa Charlin

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

[diff] [blame]

151

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

152

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

153

Optional<std::string&> reasonIfUnsupported) const

154

{

155

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

156

}

157

Teresa Charlin

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

[diff] [blame]

158

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

159

const TensorInfo&, // output

160

const Convolution2dDescriptor&, // descriptor

161

const TensorInfo&, // weights

162

const Optional<TensorInfo>&, // biases

Matteo Martincigh

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

[diff] [blame]

163

Optional<std::string&> reasonIfUnsupported) const

164

{

165

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

166

}

167

Matthew Sloyan

b63a311

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

[diff] [blame^]

168

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

169

const TensorInfo&, // output

170

const Convolution3dDescriptor&, // descriptor

171

const TensorInfo&, // weights

172

const Optional<TensorInfo>&, // biases

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::IsDebugSupported(const TensorInfo&, // input

179

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

180

Optional<std::string&> reasonIfUnsupported) const

181

{

182

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

183

}

184

Teresa Charlin

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

[diff] [blame]

185

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

186

const TensorInfo&, // output

187

const DepthToSpaceDescriptor&, // descriptor

Aron Virginas-Tar

dd6247f

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

[diff] [blame]

188

Optional<std::string&> reasonIfUnsupported) const

189

{

190

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

191

}

192

Teresa Charlin

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

[diff] [blame]

193

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

194

const TensorInfo&, //output

195

const DepthwiseConvolution2dDescriptor&, // descriptor

196

const TensorInfo&, // weights

197

const Optional<TensorInfo>&, // biases

Matteo Martincigh

2019-01-10 17:34:20 +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::IsDequantizeSupported(const TensorInfo&, // input

204

const TensorInfo&, // output

Nattapat Chaimanowong

e4294fd

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

[diff] [blame]

205

Optional<std::string&> reasonIfUnsupported) const

206

{

207

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

208

}

209

Teresa Charlin

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

[diff] [blame]

210

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

211

const TensorInfo&, // scores

212

const TensorInfo&, // anchors

213

const TensorInfo&, // detectionBoxes

214

const TensorInfo&, // detectionClasses

215

const TensorInfo&, // detectionScores

216

const TensorInfo&, // numDetections

217

const DetectionPostProcessDescriptor&, //descriptor

Derek Lamberti

6a5e5e8

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

[diff] [blame]

218

Optional<std::string&> reasonIfUnsupported) const

Narumol Prangnawarat

94dd5d8

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

[diff] [blame]

219

{

220

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

221

}

222

Teresa Charlin

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

[diff] [blame]

223

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

224

const TensorInfo&, // output

225

const DepthwiseConvolution2dDescriptor&, // descriptor

226

const TensorInfo&,// weights

227

const Optional<TensorInfo>&, // biases

Matteo Martincigh

eac246d

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

[diff] [blame]

228

Optional<std::string&> reasonIfUnsupported) const

229

{

230

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

231

}

232

Teresa Charlin

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

[diff] [blame]

233

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

234

const TensorInfo&, // input1

235

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

236

Optional<std::string&> reasonIfUnsupported) const

237

{

238

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

239

}

240

josh minor

4a3c610

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

[diff] [blame]

241

bool LayerSupportBase::IsElementwiseUnarySupported(const TensorInfo& input,

242

const TensorInfo& output,

243

const ElementwiseUnaryDescriptor& descriptor,

244

Optional<std::string&> reasonIfUnsupported) const

245

{

246

if (descriptor.m_Operation == UnaryOperation::Abs)

247

{

248

ARMNN_NO_DEPRECATE_WARN_BEGIN

249

return IsAbsSupported(input, output, reasonIfUnsupported);

250

ARMNN_NO_DEPRECATE_WARN_END

251

}

252

else if (descriptor.m_Operation == UnaryOperation::Rsqrt)

253

{

254

ARMNN_NO_DEPRECATE_WARN_BEGIN

255

return IsRsqrtSupported(input, output, reasonIfUnsupported);

256

ARMNN_NO_DEPRECATE_WARN_END

}

return false;

}

Teresa Charlin

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

[diff] [blame]

261

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

262

const armnn::TensorInfo&, // input1

263

const armnn::TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

264

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

265

{

266

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

267

}

268

Teresa Charlin

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

[diff] [blame]

269

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

270

const FakeQuantizationDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

271

Optional<std::string&> reasonIfUnsupported) const

272

{

273

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

274

}

275

Teresa Charlin

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

[diff] [blame]

276

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

277

const TensorInfo&, // output

278

const FillDescriptor&, // descriptor

Ryan OShea

ec6c680

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

[diff] [blame]

279

Optional<std::string&> reasonIfUnsupported) const

280

{

281

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

282

}

283

Teresa Charlin

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

[diff] [blame]

284

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

285

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

286

Optional<std::string&> reasonIfUnsupported) const

287

{

288

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

289

}

290

Teresa Charlin

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

[diff] [blame]

291

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

292

const TensorInfo&, // output

293

const TensorInfo&, // weights

294

const TensorInfo&, // biases

295

const FullyConnectedDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

296

Optional<std::string&> reasonIfUnsupported) const

297

{

298

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

299

}

300

Teresa Charlin

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

[diff] [blame]

301

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

302

const armnn::TensorInfo&, // input1

303

const armnn::TensorInfo&, // output

narpra01

b89b05f

2019-01-16 09:53:09 +0000

[diff] [blame]

304

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

305

{

306

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

307

}

308

Teresa Charlin

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

[diff] [blame]

309

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

310

const armnn::TensorInfo&, // input1

311

const armnn::TensorInfo&, // output

312

const GatherDescriptor&, // descriptor

313

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

314

{

315

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

316

}

317

318

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

319

const TensorInfo&, // input1

320

const TensorInfo&, // output

Matteo Martincigh

3d6898c

2019-01-15 16:11:44 +0000

[diff] [blame]

321

Optional<std::string&> reasonIfUnsupported) const

322

{

323

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

324

}

325

Teresa Charlin

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

[diff] [blame]

326

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

Matteo Martincigh

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

[diff] [blame]

327

Optional<std::string&> reasonIfUnsupported) const

328

{

329

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

330

}

331

Teresa Charlin

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

[diff] [blame]

332

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

333

const TensorInfo&, // output

334

const InstanceNormalizationDescriptor&, // descriptor

Kevin May

ce5045a

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

[diff] [blame]

335

Optional<std::string&> reasonIfUnsupported) const

336

{

337

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

338

}

339

Teresa Charlin

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

[diff] [blame]

340

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

James Conroy

aba90cd

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

[diff] [blame]

341

const TensorInfo&, // output

Teresa Charlin

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

[diff] [blame]

342

const L2NormalizationDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

343

Optional<std::string&> reasonIfUnsupported) const

344

{

345

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

346

}

347

James Conroy

aba90cd

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

[diff] [blame]

348

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

349

const TensorInfo&, // input1

350

const TensorInfo&, // output

351

const LogicalBinaryDescriptor&, // descriptor

352

Optional<std::string&> reasonIfUnsupported) const

353

{

354

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

355

}

356

357

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

358

const TensorInfo&, // output

359

const ElementwiseUnaryDescriptor&, // descriptor

360

Optional<std::string&> reasonIfUnsupported) const

361

{

362

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

363

}

364

Teresa Charlin

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

[diff] [blame]

365

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

366

const TensorInfo&, // output

367

const LogSoftmaxDescriptor&, // descriptor

Aron Virginas-Tar

f982dea

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

[diff] [blame]

368

Optional<std::string&> reasonIfUnsupported) const

369

{

370

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

371

}

372

Teresa Charlin

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

[diff] [blame]

373

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

374

const TensorInfo&, // outputStateIn

375

const TensorInfo&, // cellStateIn

376

const TensorInfo&, // scratchBuffer

377

const TensorInfo&, // outputStateOut

378

const TensorInfo&, // cellStateOut

379

const TensorInfo&, // output

380

const LstmDescriptor&, // descriptor

381

const LstmInputParamsInfo&, // paramsInfo

Jan Eilers

d01a83c

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

[diff] [blame]

382

Optional<std::string&> reasonIfUnsupported) const

Matteo Martincigh

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

[diff] [blame]

383

{

384

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

385

}

386

Teresa Charlin

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

[diff] [blame]

387

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

388

const TensorInfo&, // input1

389

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

390

Optional<std::string&> reasonIfUnsupported) const

391

{

392

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

393

}

394

Teresa Charlin

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

[diff] [blame]

395

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

396

const TensorInfo&, // output

397

const MeanDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

398

Optional<std::string&> reasonIfUnsupported) const

399

{

400

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

401

}

402

Teresa Charlin

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

[diff] [blame]

403

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

404

const armnn::TensorInfo&, // output

405

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

Matteo Martincigh

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

[diff] [blame]

406

{

Derek Lamberti

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

[diff] [blame]

return true;

}

Teresa Charlin

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

[diff] [blame]

410

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

411

const armnn::TensorInfo&, // output

412

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

Derek Lamberti

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

[diff] [blame]

413

{

Derek Lamberti

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

[diff] [blame]

414

return true;

Matteo Martincigh

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

[diff] [blame]

415

}

416

Teresa Charlin

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

[diff] [blame]

417

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

418

const TensorInfo&, // input1

419

const TensorInfo&, // output

Nattapat Chaimanowong

1f88630

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

[diff] [blame]

420

Optional<std::string&> reasonIfUnsupported) const

421

{

422

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

423

}

424

Matteo Martincigh

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

[diff] [blame]

425

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

426

const TensorInfo& output,

427

const OriginsDescriptor& descriptor,

428

Optional<std::string&> reasonIfUnsupported) const

429

{

Jim Flynn

e242f2d

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

[diff] [blame]

430

return IsConcatSupported(inputs, output, descriptor, reasonIfUnsupported);

Matteo Martincigh

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

[diff] [blame]

431

}

432

Teresa Charlin

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

[diff] [blame]

433

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

434

const TensorInfo&, // input1

435

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

436

Optional<std::string&> reasonIfUnsupported) const

437

{

438

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

439

}

440

Teresa Charlin

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

[diff] [blame]

441

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

442

const TensorInfo&, // input1

443

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

444

Optional<std::string&> reasonIfUnsupported) const

445

{

446

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

447

}

448

Teresa Charlin

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

[diff] [blame]

449

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

450

const TensorInfo&, // output

451

const NormalizationDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

452

Optional<std::string&> reasonIfUnsupported) const

453

{

454

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

455

}

456

Teresa Charlin

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

[diff] [blame]

457

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

Matteo Martincigh

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

[diff] [blame]

458

Optional<std::string&> reasonIfUnsupported) const

459

{

460

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

461

}

462

Teresa Charlin

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

[diff] [blame]

463

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

464

const TensorInfo&, // output

465

const PadDescriptor&, // descriptor

Matteo Martincigh

2019-01-10 17:34:20 +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::IsPermuteSupported(const TensorInfo&, // input

472

const TensorInfo&, // output

473

const PermuteDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

474

Optional<std::string&> reasonIfUnsupported) const

475

{

476

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

477

}

478

Teresa Charlin

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

[diff] [blame]

479

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

480

const TensorInfo&, // output

481

const Pooling2dDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

482

Optional<std::string&> reasonIfUnsupported) const

483

{

484

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

485

}

486

Teresa Charlin

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

[diff] [blame]

487

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

488

const PreCompiledDescriptor&, // descriptor

Matteo Martincigh

4912402

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

[diff] [blame]

489

Optional<std::string&> reasonIfUnsupported) const

490

{

491

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

492

}

493

Teresa Charlin

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

[diff] [blame]

494

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

495

const TensorInfo&, // alpha

496

const TensorInfo&, // output

Matteo Martincigh

0e406ee

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

[diff] [blame]

497

Optional<std::string &> reasonIfUnsupported) const

498

{

499

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

500

}

501

Teresa Charlin

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

[diff] [blame]

502

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

503

const armnn::TensorInfo&, // output

Derek Lamberti

a9cca6a

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

[diff] [blame]

504

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

505

{

506

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

507

}

508

Teresa Charlin

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

[diff] [blame]

509

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

510

const TensorInfo&, // previousOutputIn

511

const TensorInfo&, // previousCellStateIn

512

const TensorInfo&, // outputStateOut

513

const TensorInfo&, // cellStateOut

514

const TensorInfo&, // output

515

const QLstmDescriptor&, // descriptor

516

const LstmInputParamsInfo&, // paramsInfo

James Conroy

586a9aa

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

[diff] [blame]

517

Optional<std::string&> reasonIfUnsupported) const

518

{

519

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

520

}

521

Teresa Charlin

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

[diff] [blame]

522

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

523

const TensorInfo&, // previousCellStateIn

524

const TensorInfo&, // previousOutputIn

525

const TensorInfo&, // cellStateOut

526

const TensorInfo&, // output

527

const QuantizedLstmInputParamsInfo&, // paramsInfo

James Conroy

ee18dc8

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

[diff] [blame]

528

Optional<std::string&> reasonIfUnsupported) const

529

{

530

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

531

}

532

Finn Williams

2605b23

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

[diff] [blame]

533

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

534

const TensorInfo&, // output

535

Optional<std::string&> reasonIfUnsupported) const

536

{

537

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

538

}

539

Sadik Armagan

0c3ea5b

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

[diff] [blame]

540

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

541

const TensorInfo& /*output*/,

542

const ReduceDescriptor& /*descriptor*/,

543

Optional<std::string&> reasonIfUnsupported) const

544

{

545

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

546

}

547

Teresa Charlin

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

[diff] [blame]

548

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

549

const TensorInfo&, // output

550

const ReshapeDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

551

Optional<std::string&> reasonIfUnsupported) const

552

{

553

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

554

}

555

Teresa Charlin

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

[diff] [blame]

556

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

557

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

558

Optional<std::string&> reasonIfUnsupported) const

559

{

560

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

561

}

562

Teresa Charlin

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

[diff] [blame]

563

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

564

const TensorInfo&, // output

565

const ResizeDescriptor&, // descriptor

Teresa Charlin

a9075df

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

[diff] [blame]

566

Optional<std::string&> reasonIfUnsupported) const

567

{

568

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

569

}

570

Teresa Charlin

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

[diff] [blame]

571

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

572

const TensorInfo&, // output

Matteo Martincigh

3d6898c

2019-01-15 16:11:44 +0000

[diff] [blame]

573

Optional<std::string &> reasonIfUnsupported) const

574

{

575

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

576

}

577

Keith Davis

3ae3f97

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

[diff] [blame]

578

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

579

const TensorInfo&, // output

580

Optional<std::string&> reasonIfUnsupported) const

581

{

582

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

583

}

584

Teresa Charlin

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

[diff] [blame]

585

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

586

const TensorInfo&, // output

587

const SliceDescriptor&, // descriptor

Aron Virginas-Tar

636ab40

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

[diff] [blame]

588

Optional<std::string&> reasonIfUnsupported) const

589

{

590

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

591

}

592

Teresa Charlin

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

[diff] [blame]

593

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

594

const TensorInfo&, // output

595

const SoftmaxDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

596

Optional<std::string&> reasonIfUnsupported) const

597

{

598

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

599

}

Derek Lamberti

901ea11

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

[diff] [blame]

600

/**/

Teresa Charlin

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

[diff] [blame]

601

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

602

const TensorInfo&, // output

603

const SpaceToBatchNdDescriptor&, // descriptor

Matteo Martincigh

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

[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::IsSpaceToDepthSupported(const TensorInfo&, // input

610

const TensorInfo&, // output

611

const SpaceToDepthDescriptor&, // descriptor

Aron Virginas-Tar

972af15

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

[diff] [blame]

612

Optional<std::string&> reasonIfUnsupported) const

613

{

614

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

615

}

616

Teresa Charlin

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

[diff] [blame]

617

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

618

const ViewsDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

619

Optional<std::string&> reasonIfUnsupported) const

620

{

621

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

622

}

623

Teresa Charlin

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

[diff] [blame]

624

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

625

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

626

const ViewsDescriptor&, // descriptor

Narumol Prangnawarat

15eb583

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

[diff] [blame]

627

Optional<std::string&> reasonIfUnsupported) const

628

{

629

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

630

}

631

Teresa Charlin

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

[diff] [blame]

632

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

633

const TensorInfo&, // output

634

const StackDescriptor&, // descriptor

Matthew Jackson

2b8c1da

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

[diff] [blame]

635

Optional<std::string&> reasonIfUnsupported) const

636

{

637

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

638

}

639

Teresa Charlin

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

[diff] [blame]

640

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

641

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

642

const StandInDescriptor&, // descriptor

Derek Lamberti

013c390

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

[diff] [blame]

643

Optional<std::string&> reasonIfUnsupported) const

644

{

645

if (reasonIfUnsupported)

646

{

647

std::stringstream message;

648

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

649

650

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

}

return false;

}

Teresa Charlin

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

[diff] [blame]

656

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

657

const TensorInfo&, // output

658

const StridedSliceDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

659

Optional<std::string&> reasonIfUnsupported) const

660

{

661

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

662

}

663

Teresa Charlin

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

[diff] [blame]

664

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

665

const TensorInfo&, // input1

666

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

667

Optional<std::string&> reasonIfUnsupported) const

668

{

669

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

670

}

671

Teresa Charlin

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

[diff] [blame]

672

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

673

const TensorInfo&, // input1

674

const TensorInfo&, // output0

675

const TensorInfo&, // output1

Sadik Armagan

eff363d

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

[diff] [blame]

676

Optional<std::string&> reasonIfUnsupported) const

677

{

678

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

679

}

680

Teresa Charlin

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

[diff] [blame]

681

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

682

const TensorInfo&, // output

683

const TransposeConvolution2dDescriptor&, // descriptor

684

const TensorInfo&, // weights

685

const Optional<TensorInfo>&, // biases

Aron Virginas-Tar

639fb04

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

[diff] [blame]

686

Optional<std::string&> reasonIfUnsupported) const

687

{

688

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

Teresa Charlin

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

[diff] [blame]

689

}

Aron Virginas-Tar

639fb04

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

[diff] [blame]

690

Teresa Charlin

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

[diff] [blame]

691

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

692

const TensorInfo&, // output

693

const TransposeDescriptor&, // descriptor

Mike Kelly

c9ea45a

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

[diff] [blame]

694

Optional<std::string&> reasonIfUnsupported) const

695

{

696

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

697

}

698

Narumol Prangnawarat

8ed39ae

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

[diff] [blame]

699

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

700

const TensorInfo&, // outputStateIn

701

const TensorInfo&, // cellStateIn

702

const TensorInfo&, // output

703

const Optional<TensorInfo>&, // hiddenStateOut

704

const Optional<TensorInfo>&, // cellStateOut

705

const LstmDescriptor&, // descriptor

706

const LstmInputParamsInfo&, // paramsInfo

707

Optional<std::string&> reasonIfUnsupported) const

708

{

709

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

710

}

711

Matteo Martincigh