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

Teresa Charlin

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

[diff] [blame]

168

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

169

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

170

Optional<std::string&> reasonIfUnsupported) const

171

{

172

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

173

}

174

Teresa Charlin

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

[diff] [blame]

175

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

176

const TensorInfo&, // output

177

const DepthToSpaceDescriptor&, // descriptor

Aron Virginas-Tar

dd6247f

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

[diff] [blame]

178

Optional<std::string&> reasonIfUnsupported) const

179

{

180

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

181

}

182

Teresa Charlin

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

[diff] [blame]

183

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

184

const TensorInfo&, //output

185

const DepthwiseConvolution2dDescriptor&, // descriptor

186

const TensorInfo&, // weights

187

const Optional<TensorInfo>&, // biases

Matteo Martincigh

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

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

194

const TensorInfo&, // output

Nattapat Chaimanowong

e4294fd

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

[diff] [blame]

195

Optional<std::string&> reasonIfUnsupported) const

196

{

197

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

198

}

199

Teresa Charlin

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

[diff] [blame]

200

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

201

const TensorInfo&, // scores

202

const TensorInfo&, // anchors

203

const TensorInfo&, // detectionBoxes

204

const TensorInfo&, // detectionClasses

205

const TensorInfo&, // detectionScores

206

const TensorInfo&, // numDetections

207

const DetectionPostProcessDescriptor&, //descriptor

Derek Lamberti

6a5e5e8

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

[diff] [blame]

208

Optional<std::string&> reasonIfUnsupported) const

Narumol Prangnawarat

94dd5d8

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

[diff] [blame]

209

{

210

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

211

}

212

Teresa Charlin

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

[diff] [blame]

213

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

214

const TensorInfo&, // output

215

const DepthwiseConvolution2dDescriptor&, // descriptor

216

const TensorInfo&,// weights

217

const Optional<TensorInfo>&, // biases

Matteo Martincigh

eac246d

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

[diff] [blame]

218

Optional<std::string&> reasonIfUnsupported) const

219

{

220

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

221

}

222

Teresa Charlin

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

[diff] [blame]

223

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

224

const TensorInfo&, // input1

225

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

226

Optional<std::string&> reasonIfUnsupported) const

227

{

228

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

229

}

230

josh minor

4a3c610

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

[diff] [blame]

231

bool LayerSupportBase::IsElementwiseUnarySupported(const TensorInfo& input,

232

const TensorInfo& output,

233

const ElementwiseUnaryDescriptor& descriptor,

234

Optional<std::string&> reasonIfUnsupported) const

235

{

236

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

237

{

238

ARMNN_NO_DEPRECATE_WARN_BEGIN

239

return IsAbsSupported(input, output, reasonIfUnsupported);

240

ARMNN_NO_DEPRECATE_WARN_END

241

}

242

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

243

{

244

ARMNN_NO_DEPRECATE_WARN_BEGIN

245

return IsRsqrtSupported(input, output, reasonIfUnsupported);

246

ARMNN_NO_DEPRECATE_WARN_END

}

return false;

}

Teresa Charlin

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

[diff] [blame]

251

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

252

const armnn::TensorInfo&, // input1

253

const armnn::TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

254

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

255

{

256

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

257

}

258

Teresa Charlin

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

[diff] [blame]

259

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

260

const FakeQuantizationDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

261

Optional<std::string&> reasonIfUnsupported) const

262

{

263

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

264

}

265

Teresa Charlin

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

[diff] [blame]

266

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

267

const TensorInfo&, // output

268

const FillDescriptor&, // descriptor

Ryan OShea

ec6c680

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

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

275

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

276

Optional<std::string&> reasonIfUnsupported) const

277

{

278

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

279

}

280

Teresa Charlin

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

[diff] [blame]

281

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

282

const TensorInfo&, // output

283

const TensorInfo&, // weights

284

const TensorInfo&, // biases

285

const FullyConnectedDescriptor&, // descriptor

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::IsGatherSupported(const armnn::TensorInfo&, // input0

292

const armnn::TensorInfo&, // input1

293

const armnn::TensorInfo&, // output

narpra01

b89b05f

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

[diff] [blame]

294

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

295

{

296

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

297

}

298

Teresa Charlin

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

[diff] [blame]

299

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

300

const armnn::TensorInfo&, // input1

301

const armnn::TensorInfo&, // output

302

const GatherDescriptor&, // descriptor

303

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

304

{

305

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

306

}

307

308

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

309

const TensorInfo&, // input1

310

const TensorInfo&, // output

Matteo Martincigh

3d6898c

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

[diff] [blame]

311

Optional<std::string&> reasonIfUnsupported) const

312

{

313

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

314

}

315

Teresa Charlin

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

[diff] [blame]

316

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

Matteo Martincigh

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

[diff] [blame]

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

323

const TensorInfo&, // output

324

const InstanceNormalizationDescriptor&, // descriptor

Kevin May

ce5045a

2019-10-02 14:07:47 +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::IsL2NormalizationSupported(const TensorInfo&, // input

James Conroy

aba90cd

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

[diff] [blame]

331

const TensorInfo&, // output

Teresa Charlin

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

[diff] [blame]

332

const L2NormalizationDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

333

Optional<std::string&> reasonIfUnsupported) const

334

{

335

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

336

}

337

James Conroy

aba90cd

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

[diff] [blame]

338

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

339

const TensorInfo&, // input1

340

const TensorInfo&, // output

341

const LogicalBinaryDescriptor&, // descriptor

342

Optional<std::string&> reasonIfUnsupported) const

343

{

344

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

345

}

346

347

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

348

const TensorInfo&, // output

349

const ElementwiseUnaryDescriptor&, // descriptor

350

Optional<std::string&> reasonIfUnsupported) const

351

{

352

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

353

}

354

Teresa Charlin

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

[diff] [blame]

355

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

356

const TensorInfo&, // output

357

const LogSoftmaxDescriptor&, // descriptor

Aron Virginas-Tar

f982dea

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

[diff] [blame]

358

Optional<std::string&> reasonIfUnsupported) const

359

{

360

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

361

}

362

Teresa Charlin

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

[diff] [blame]

363

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

364

const TensorInfo&, // outputStateIn

365

const TensorInfo&, // cellStateIn

366

const TensorInfo&, // scratchBuffer

367

const TensorInfo&, // outputStateOut

368

const TensorInfo&, // cellStateOut

369

const TensorInfo&, // output

370

const LstmDescriptor&, // descriptor

371

const LstmInputParamsInfo&, // paramsInfo

Jan Eilers

d01a83c

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

[diff] [blame]

372

Optional<std::string&> reasonIfUnsupported) const

Matteo Martincigh

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

[diff] [blame]

373

{

374

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

375

}

376

Teresa Charlin

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

[diff] [blame]

377

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

378

const TensorInfo&, // input1

379

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

380

Optional<std::string&> reasonIfUnsupported) const

381

{

382

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

383

}

384

Teresa Charlin

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

[diff] [blame]

385

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

386

const TensorInfo&, // output

387

const MeanDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

388

Optional<std::string&> reasonIfUnsupported) const

389

{

390

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

391

}

392

Teresa Charlin

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

[diff] [blame]

393

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

394

const armnn::TensorInfo&, // output

395

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

Matteo Martincigh

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

[diff] [blame]

396

{

Derek Lamberti

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

[diff] [blame]

return true;

}

Teresa Charlin

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

[diff] [blame]

400

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

401

const armnn::TensorInfo&, // output

402

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

Derek Lamberti

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

[diff] [blame]

403

{

Derek Lamberti

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

[diff] [blame]

404

return true;

Matteo Martincigh

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

[diff] [blame]

405

}

406

Teresa Charlin

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

[diff] [blame]

407

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

408

const TensorInfo&, // input1

409

const TensorInfo&, // output

Nattapat Chaimanowong

1f88630

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

[diff] [blame]

410

Optional<std::string&> reasonIfUnsupported) const

411

{

412

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

413

}

414

Matteo Martincigh

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

[diff] [blame]

415

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

416

const TensorInfo& output,

417

const OriginsDescriptor& descriptor,

418

Optional<std::string&> reasonIfUnsupported) const

419

{

Jim Flynn

e242f2d

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

[diff] [blame]

420

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

Matteo Martincigh

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

[diff] [blame]

421

}

422

Teresa Charlin

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

[diff] [blame]

423

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

424

const TensorInfo&, // input1

425

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

426

Optional<std::string&> reasonIfUnsupported) const

427

{

428

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

429

}

430

Teresa Charlin

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

[diff] [blame]

431

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

432

const TensorInfo&, // input1

433

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

434

Optional<std::string&> reasonIfUnsupported) const

435

{

436

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

437

}

438

Teresa Charlin

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

[diff] [blame]

439

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

440

const TensorInfo&, // output

441

const NormalizationDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

442

Optional<std::string&> reasonIfUnsupported) const

443

{

444

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

445

}

446

Teresa Charlin

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

[diff] [blame]

447

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

Matteo Martincigh

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

[diff] [blame]

448

Optional<std::string&> reasonIfUnsupported) const

449

{

450

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

451

}

452

Teresa Charlin

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

[diff] [blame]

453

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

454

const TensorInfo&, // output

455

const PadDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

456

Optional<std::string&> reasonIfUnsupported) const

457

{

458

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

459

}

460

Teresa Charlin

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

[diff] [blame]

461

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

462

const TensorInfo&, // output

463

const PermuteDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

464

Optional<std::string&> reasonIfUnsupported) const

465

{

466

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

467

}

468

Teresa Charlin

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

[diff] [blame]

469

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

470

const TensorInfo&, // output

471

const Pooling2dDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

472

Optional<std::string&> reasonIfUnsupported) const

473

{

474

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

475

}

476

Teresa Charlin

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

[diff] [blame]

477

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

478

const PreCompiledDescriptor&, // descriptor

Matteo Martincigh

4912402

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

[diff] [blame]

479

Optional<std::string&> reasonIfUnsupported) const

480

{

481

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

482

}

483

Teresa Charlin

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

[diff] [blame]

484

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

485

const TensorInfo&, // alpha

486

const TensorInfo&, // output

Matteo Martincigh

0e406ee

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

[diff] [blame]

487

Optional<std::string &> reasonIfUnsupported) const

488

{

489

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

490

}

491

Teresa Charlin

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

[diff] [blame]

492

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

493

const armnn::TensorInfo&, // output

Derek Lamberti

a9cca6a

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

[diff] [blame]

494

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

495

{

496

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

497

}

498

Teresa Charlin

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

[diff] [blame]

499

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

500

const TensorInfo&, // previousOutputIn

501

const TensorInfo&, // previousCellStateIn

502

const TensorInfo&, // outputStateOut

503

const TensorInfo&, // cellStateOut

504

const TensorInfo&, // output

505

const QLstmDescriptor&, // descriptor

506

const LstmInputParamsInfo&, // paramsInfo

James Conroy

586a9aa

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

[diff] [blame]

507

Optional<std::string&> reasonIfUnsupported) const

508

{

509

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

510

}

511

Teresa Charlin

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

[diff] [blame]

512

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

513

const TensorInfo&, // previousCellStateIn

514

const TensorInfo&, // previousOutputIn

515

const TensorInfo&, // cellStateOut

516

const TensorInfo&, // output

517

const QuantizedLstmInputParamsInfo&, // paramsInfo

James Conroy

ee18dc8

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

[diff] [blame]

518

Optional<std::string&> reasonIfUnsupported) const

519

{

520

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

521

}

522

Finn Williams

2605b23

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

[diff] [blame]

523

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

524

const TensorInfo&, // output

525

Optional<std::string&> reasonIfUnsupported) const

526

{

527

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

528

}

529

Sadik Armagan

0c3ea5b

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

[diff] [blame]

530

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

531

const TensorInfo& /*output*/,

532

const ReduceDescriptor& /*descriptor*/,

533

Optional<std::string&> reasonIfUnsupported) const

534

{

535

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

536

}

537

Teresa Charlin

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

[diff] [blame]

538

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

539

const TensorInfo&, // output

540

const ReshapeDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

541

Optional<std::string&> reasonIfUnsupported) const

542

{

543

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

544

}

545

Teresa Charlin

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

[diff] [blame]

546

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

547

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

548

Optional<std::string&> reasonIfUnsupported) const

549

{

550

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

551

}

552

Teresa Charlin

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

[diff] [blame]

553

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

554

const TensorInfo&, // output

555

const ResizeDescriptor&, // descriptor

Teresa Charlin

a9075df

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

[diff] [blame]

556

Optional<std::string&> reasonIfUnsupported) const

557

{

558

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

559

}

560

Teresa Charlin

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

[diff] [blame]

561

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

562

const TensorInfo&, // output

Matteo Martincigh

3d6898c

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

[diff] [blame]

563

Optional<std::string &> reasonIfUnsupported) const

564

{

565

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

566

}

567

Keith Davis

3ae3f97

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

[diff] [blame]

568

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

569

const TensorInfo&, // output

570

Optional<std::string&> reasonIfUnsupported) const

571

{

572

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

573

}

574

Teresa Charlin

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

[diff] [blame]

575

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

576

const TensorInfo&, // output

577

const SliceDescriptor&, // descriptor

Aron Virginas-Tar

636ab40

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

[diff] [blame]

578

Optional<std::string&> reasonIfUnsupported) const

579

{

580

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

581

}

582

Teresa Charlin

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

[diff] [blame]

583

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

584

const TensorInfo&, // output

585

const SoftmaxDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

586

Optional<std::string&> reasonIfUnsupported) const

587

{

588

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

589

}

Derek Lamberti

901ea11

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

[diff] [blame]

590

/**/

Teresa Charlin

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

[diff] [blame]

591

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

592

const TensorInfo&, // output

593

const SpaceToBatchNdDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

594

Optional<std::string&> reasonIfUnsupported) const

595

{

596

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

597

}

598

Teresa Charlin

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

[diff] [blame]

599

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

600

const TensorInfo&, // output

601

const SpaceToDepthDescriptor&, // descriptor

Aron Virginas-Tar

972af15

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

[diff] [blame]

602

Optional<std::string&> reasonIfUnsupported) const

603

{

604

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

605

}

606

Teresa Charlin

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

[diff] [blame]

607

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

608

const ViewsDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

609

Optional<std::string&> reasonIfUnsupported) const

610

{

611

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

612

}

613

Teresa Charlin

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

[diff] [blame]

614

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

615

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

616

const ViewsDescriptor&, // descriptor

Narumol Prangnawarat

15eb583

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

[diff] [blame]

617

Optional<std::string&> reasonIfUnsupported) const

618

{

619

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

620

}

621

Teresa Charlin

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

[diff] [blame]

622

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

623

const TensorInfo&, // output

624

const StackDescriptor&, // descriptor

Matthew Jackson

2b8c1da

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

[diff] [blame]

625

Optional<std::string&> reasonIfUnsupported) const

626

{

627

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

628

}

629

Teresa Charlin

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

[diff] [blame]

630

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

631

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

632

const StandInDescriptor&, // descriptor

Derek Lamberti

013c390

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

[diff] [blame]

633

Optional<std::string&> reasonIfUnsupported) const

634

{

635

if (reasonIfUnsupported)

636

{

637

std::stringstream message;

638

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

639

640

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

}

return false;

}

Teresa Charlin

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

[diff] [blame]

646

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

647

const TensorInfo&, // output

648

const StridedSliceDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

649

Optional<std::string&> reasonIfUnsupported) const

650

{

651

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

652

}

653

Teresa Charlin

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

[diff] [blame]

654

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

655

const TensorInfo&, // input1

656

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

657

Optional<std::string&> reasonIfUnsupported) const

658

{

659

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

660

}

661

Teresa Charlin

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

[diff] [blame]

662

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

663

const TensorInfo&, // input1

664

const TensorInfo&, // output0

665

const TensorInfo&, // output1

Sadik Armagan

eff363d

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

[diff] [blame]

666

Optional<std::string&> reasonIfUnsupported) const

667

{

668

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

669

}

670

Teresa Charlin

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

[diff] [blame]

671

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

672

const TensorInfo&, // output

673

const TransposeConvolution2dDescriptor&, // descriptor

674

const TensorInfo&, // weights

675

const Optional<TensorInfo>&, // biases

Aron Virginas-Tar

639fb04

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

[diff] [blame]

676

Optional<std::string&> reasonIfUnsupported) const

677

{

678

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

Teresa Charlin

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

[diff] [blame]

679

}

Aron Virginas-Tar

639fb04

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

[diff] [blame]

680

Teresa Charlin

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

[diff] [blame]

681

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

682

const TensorInfo&, // output

683

const TransposeDescriptor&, // descriptor

Mike Kelly

c9ea45a

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

[diff] [blame]

684

Optional<std::string&> reasonIfUnsupported) const

685

{

686

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

687

}

688

Narumol Prangnawarat

8ed39ae

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

[diff] [blame]

689

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

690

const TensorInfo&, // outputStateIn

691

const TensorInfo&, // cellStateIn

692

const TensorInfo&, // output

693

const Optional<TensorInfo>&, // hiddenStateOut

694

const Optional<TensorInfo>&, // cellStateOut

695

const LstmDescriptor&, // descriptor

696

const LstmInputParamsInfo&, // paramsInfo

697

Optional<std::string&> reasonIfUnsupported) const

698

{

699

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

700

}

701

Matteo Martincigh