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

Teresa Charlin

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

[diff] [blame]

91

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

92

const TensorInfo&, // input1

93

const TensorInfo&, // output

94

const ComparisonDescriptor&, // descriptor

Aron Virginas-Tar

77bfb5e

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

[diff] [blame]

95

Optional<std::string&> reasonIfUnsupported) const

96

{

97

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

98

}

99

Teresa Charlin

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

[diff] [blame]

100

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

101

const TensorInfo&, // output

102

const OriginsDescriptor&, // descriptor

Jim Flynn

906f946

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

[diff] [blame]

103

Optional<std::string&> reasonIfUnsupported) const

104

{

Jim Flynn

e242f2d

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

[diff] [blame]

105

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

Jim Flynn

906f946

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

[diff] [blame]

106

}

107

Teresa Charlin

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

[diff] [blame]

108

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

Matteo Martincigh

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

[diff] [blame]

109

Optional<std::string&> reasonIfUnsupported) const

110

{

111

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

112

}

113

Teresa Charlin

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

[diff] [blame]

114

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

115

const TensorInfo&, // output

Narumol Prangnawarat

7ddbbae

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

[diff] [blame]

116

Optional<std::string&> reasonIfUnsupported) const

117

{

118

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

119

}

120

Teresa Charlin

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

[diff] [blame]

121

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

122

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

123

Optional<std::string&> reasonIfUnsupported) const

124

{

125

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

126

}

127

Teresa Charlin

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

[diff] [blame]

128

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

129

const TensorInfo&, // output

Narumol Prangnawarat

ea54a01

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

[diff] [blame]

130

Optional<std::string&> reasonIfUnsupported) const

131

{

132

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

}

Teresa Charlin

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

[diff] [blame]

136

bool LayerSupportBase::IsConvertFp32ToFp16Supported(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::IsConvolution2dSupported(const TensorInfo&, // input

144

const TensorInfo&, // output

145

const Convolution2dDescriptor&, // descriptor

146

const TensorInfo&, // weights

147

const Optional<TensorInfo>&, // biases

Matteo Martincigh

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

[diff] [blame]

148

Optional<std::string&> reasonIfUnsupported) const

149

{

150

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

151

}

152

Teresa Charlin

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

[diff] [blame]

153

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

154

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

155

Optional<std::string&> reasonIfUnsupported) const

156

{

157

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

158

}

159

Teresa Charlin

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

[diff] [blame]

160

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

161

const TensorInfo&, // output

162

const DepthToSpaceDescriptor&, // descriptor

Aron Virginas-Tar

dd6247f

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

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

169

const TensorInfo&, //output

170

const DepthwiseConvolution2dDescriptor&, // descriptor

171

const TensorInfo&, // weights

172

const Optional<TensorInfo>&, // biases

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

179

const TensorInfo&, // output

Nattapat Chaimanowong

e4294fd

2019-03-28 09:56:53 +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::IsDetectionPostProcessSupported(const TensorInfo&, // boxEncodings

186

const TensorInfo&, // scores

187

const TensorInfo&, // anchors

188

const TensorInfo&, // detectionBoxes

189

const TensorInfo&, // detectionClasses

190

const TensorInfo&, // detectionScores

191

const TensorInfo&, // numDetections

192

const DetectionPostProcessDescriptor&, //descriptor

Derek Lamberti

6a5e5e8

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

[diff] [blame]

193

Optional<std::string&> reasonIfUnsupported) const

Narumol Prangnawarat

94dd5d8

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

[diff] [blame]

194

{

195

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

196

}

197

Teresa Charlin

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

[diff] [blame]

198

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

199

const TensorInfo&, // output

200

const DepthwiseConvolution2dDescriptor&, // descriptor

201

const TensorInfo&,// weights

202

const Optional<TensorInfo>&, // biases

Matteo Martincigh

eac246d

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

[diff] [blame]

203

Optional<std::string&> reasonIfUnsupported) const

204

{

205

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

206

}

207

Teresa Charlin

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

[diff] [blame]

208

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

209

const TensorInfo&, // input1

210

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

211

Optional<std::string&> reasonIfUnsupported) const

212

{

213

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

214

}

215

josh minor

4a3c610

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

[diff] [blame]

216

bool LayerSupportBase::IsElementwiseUnarySupported(const TensorInfo& input,

217

const TensorInfo& output,

218

const ElementwiseUnaryDescriptor& descriptor,

219

Optional<std::string&> reasonIfUnsupported) const

220

{

221

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

222

{

223

ARMNN_NO_DEPRECATE_WARN_BEGIN

224

return IsAbsSupported(input, output, reasonIfUnsupported);

225

ARMNN_NO_DEPRECATE_WARN_END

226

}

227

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

228

{

229

ARMNN_NO_DEPRECATE_WARN_BEGIN

230

return IsRsqrtSupported(input, output, reasonIfUnsupported);

231

ARMNN_NO_DEPRECATE_WARN_END

}

return false;

}

Teresa Charlin

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

[diff] [blame]

236

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

237

const armnn::TensorInfo&, // input1

238

const armnn::TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

239

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

240

{

241

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

242

}

243

Teresa Charlin

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

[diff] [blame]

244

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

245

const FakeQuantizationDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

246

Optional<std::string&> reasonIfUnsupported) const

247

{

248

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

249

}

250

Teresa Charlin

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

[diff] [blame]

251

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

252

const TensorInfo&, // output

253

const FillDescriptor&, // descriptor

Ryan OShea

ec6c680

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

[diff] [blame]

254

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

260

const TensorInfo&, // output

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

267

const TensorInfo&, // output

268

const TensorInfo&, // weights

269

const TensorInfo&, // biases

270

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

277

const armnn::TensorInfo&, // input1

278

const armnn::TensorInfo&, // output

narpra01

b89b05f

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

[diff] [blame]

279

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

285

const armnn::TensorInfo&, // input1

286

const armnn::TensorInfo&, // output

287

const GatherDescriptor&, // descriptor

288

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

289

{

290

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

291

}

292

293

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

294

const TensorInfo&, // input1

295

const TensorInfo&, // output

Matteo Martincigh

3d6898c

2019-01-15 16:11:44 +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::IsInputSupported(const TensorInfo&, // input

Matteo Martincigh

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

[diff] [blame]

302

Optional<std::string&> reasonIfUnsupported) const

303

{

304

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

305

}

306

Teresa Charlin

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

[diff] [blame]

307

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

308

const TensorInfo&, // output

309

const InstanceNormalizationDescriptor&, // descriptor

Kevin May

ce5045a

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

[diff] [blame]

310

Optional<std::string&> reasonIfUnsupported) const

311

{

312

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

313

}

314

Teresa Charlin

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

[diff] [blame]

315

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

316

const TensorInfo&, // output

317

const L2NormalizationDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

318

Optional<std::string&> reasonIfUnsupported) const

319

{

320

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

321

}

322

Teresa Charlin

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

[diff] [blame]

323

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

324

const TensorInfo&, // output

325

const LogSoftmaxDescriptor&, // descriptor

Aron Virginas-Tar

f982dea

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

[diff] [blame]

326

Optional<std::string&> reasonIfUnsupported) const

327

{

328

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

329

}

330

Teresa Charlin

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

[diff] [blame]

331

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

332

const TensorInfo&, // outputStateIn

333

const TensorInfo&, // cellStateIn

334

const TensorInfo&, // scratchBuffer

335

const TensorInfo&, // outputStateOut

336

const TensorInfo&, // cellStateOut

337

const TensorInfo&, // output

338

const LstmDescriptor&, // descriptor

339

const LstmInputParamsInfo&, // paramsInfo

Jan Eilers

d01a83c

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

[diff] [blame]

340

Optional<std::string&> reasonIfUnsupported) const

Matteo Martincigh

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

[diff] [blame]

341

{

342

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

343

}

344

Teresa Charlin

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

[diff] [blame]

345

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

346

const TensorInfo&, // input1

347

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

348

Optional<std::string&> reasonIfUnsupported) const

349

{

350

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

351

}

352

Teresa Charlin

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

[diff] [blame]

353

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

354

const TensorInfo&, // output

355

const MeanDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

356

Optional<std::string&> reasonIfUnsupported) const

357

{

358

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

359

}

360

Teresa Charlin

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

[diff] [blame]

361

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

362

const armnn::TensorInfo&, // output

363

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

Matteo Martincigh

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

[diff] [blame]

364

{

Derek Lamberti

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

[diff] [blame]

return true;

}

Teresa Charlin

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

[diff] [blame]

368

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

369

const armnn::TensorInfo&, // output

370

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

Derek Lamberti

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

[diff] [blame]

371

{

Derek Lamberti

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

[diff] [blame]

372

return true;

Matteo Martincigh

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

[diff] [blame]

373

}

374

Teresa Charlin

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

[diff] [blame]

375

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

376

const TensorInfo&, // input1

377

const TensorInfo&, // output

Nattapat Chaimanowong

1f88630

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

[diff] [blame]

378

Optional<std::string&> reasonIfUnsupported) const

379

{

380

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

381

}

382

Matteo Martincigh

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

[diff] [blame]

383

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

384

const TensorInfo& output,

385

const OriginsDescriptor& descriptor,

386

Optional<std::string&> reasonIfUnsupported) const

387

{

Jim Flynn

e242f2d

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

[diff] [blame]

388

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

Matteo Martincigh

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

[diff] [blame]

389

}

390

Teresa Charlin

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

[diff] [blame]

391

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

392

const TensorInfo&, // input1

393

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

394

Optional<std::string&> reasonIfUnsupported) const

395

{

396

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

397

}

398

Teresa Charlin

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

[diff] [blame]

399

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

400

const TensorInfo&, // input1

401

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

402

Optional<std::string&> reasonIfUnsupported) const

403

{

404

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

405

}

406

Teresa Charlin

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

[diff] [blame]

407

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

408

const TensorInfo&, // output

409

const NormalizationDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

410

Optional<std::string&> reasonIfUnsupported) const

411

{

412

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

413

}

414

Teresa Charlin

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

[diff] [blame]

415

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

Matteo Martincigh

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

[diff] [blame]

416

Optional<std::string&> reasonIfUnsupported) const

417

{

418

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

419

}

420

Teresa Charlin

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

[diff] [blame]

421

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

422

const TensorInfo&, // output

423

const PadDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

424

Optional<std::string&> reasonIfUnsupported) const

425

{

426

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

427

}

428

Teresa Charlin

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

[diff] [blame]

429

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

430

const TensorInfo&, // output

431

const PermuteDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

432

Optional<std::string&> reasonIfUnsupported) const

433

{

434

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

435

}

436

Teresa Charlin

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

[diff] [blame]

437

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

438

const TensorInfo&, // output

439

const Pooling2dDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

440

Optional<std::string&> reasonIfUnsupported) const

441

{

442

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

443

}

444

Teresa Charlin

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

[diff] [blame]

445

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

446

const PreCompiledDescriptor&, // descriptor

Matteo Martincigh

4912402

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

[diff] [blame]

447

Optional<std::string&> reasonIfUnsupported) const

448

{

449

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

450

}

451

Teresa Charlin

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

[diff] [blame]

452

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

453

const TensorInfo&, // alpha

454

const TensorInfo&, // output

Matteo Martincigh

0e406ee

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

[diff] [blame]

455

Optional<std::string &> reasonIfUnsupported) const

456

{

457

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

458

}

459

Teresa Charlin

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

[diff] [blame]

460

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

461

const armnn::TensorInfo&, // output

Derek Lamberti

a9cca6a

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

[diff] [blame]

462

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

463

{

464

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

465

}

466

Teresa Charlin

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

[diff] [blame]

467

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

468

const TensorInfo&, // previousOutputIn

469

const TensorInfo&, // previousCellStateIn

470

const TensorInfo&, // outputStateOut

471

const TensorInfo&, // cellStateOut

472

const TensorInfo&, // output

473

const QLstmDescriptor&, // descriptor

474

const LstmInputParamsInfo&, // paramsInfo

James Conroy

586a9aa

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

[diff] [blame]

475

Optional<std::string&> reasonIfUnsupported) const

476

{

477

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

478

}

479

Teresa Charlin

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

[diff] [blame]

480

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

481

const TensorInfo&, // previousCellStateIn

482

const TensorInfo&, // previousOutputIn

483

const TensorInfo&, // cellStateOut

484

const TensorInfo&, // output

485

const QuantizedLstmInputParamsInfo&, // paramsInfo

James Conroy

ee18dc8

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

[diff] [blame]

486

Optional<std::string&> reasonIfUnsupported) const

487

{

488

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

489

}

490

Finn Williams

2605b23

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

[diff] [blame]

491

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

492

const TensorInfo&, // output

493

Optional<std::string&> reasonIfUnsupported) const

494

{

495

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

496

}

497

Teresa Charlin

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

[diff] [blame]

498

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

499

const TensorInfo&, // output

500

const ReshapeDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

501

Optional<std::string&> reasonIfUnsupported) const

502

{

503

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

504

}

505

Teresa Charlin

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

[diff] [blame]

506

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

507

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

508

Optional<std::string&> reasonIfUnsupported) const

509

{

510

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

511

}

512

Teresa Charlin

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

[diff] [blame]

513

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

514

const TensorInfo&, // output

515

const ResizeDescriptor&, // descriptor

Teresa Charlin

a9075df

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

[diff] [blame]

516

Optional<std::string&> reasonIfUnsupported) const

517

{

518

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

519

}

520

Teresa Charlin

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

[diff] [blame]

521

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

522

const TensorInfo&, // output

Matteo Martincigh

3d6898c

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

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

529

const TensorInfo&, // output

530

const SliceDescriptor&, // descriptor

Aron Virginas-Tar

636ab40

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

[diff] [blame]

531

Optional<std::string&> reasonIfUnsupported) const

532

{

533

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

534

}

535

Teresa Charlin

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

[diff] [blame]

536

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

537

const TensorInfo&, // output

538

const SoftmaxDescriptor&, // 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

}

Derek Lamberti

901ea11

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

[diff] [blame]

543

/**/

Teresa Charlin

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

[diff] [blame]

544

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

545

const TensorInfo&, // output

546

const SpaceToBatchNdDescriptor&, // descriptor

Matteo Martincigh

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

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

553

const TensorInfo&, // output

554

const SpaceToDepthDescriptor&, // descriptor

Aron Virginas-Tar

972af15

2019-06-11 14:14:03 +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::IsSplitterSupported(const TensorInfo&, // input

561

const ViewsDescriptor&, // descriptor

Matteo Martincigh

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

[diff] [blame]

562

Optional<std::string&> reasonIfUnsupported) const

563

{

564

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

565

}

566

Teresa Charlin

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

[diff] [blame]

567

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

568

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

569

const ViewsDescriptor&, // descriptor

Narumol Prangnawarat

15eb583

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

[diff] [blame]

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::IsStackSupported(const std::vector<const TensorInfo*>&, // inputs

576

const TensorInfo&, // output

577

const StackDescriptor&, // descriptor

Matthew Jackson

2b8c1da

2019-07-04 14:59:16 +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::IsStandInSupported(const std::vector<const TensorInfo*>&, // inputs

584

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

585

const StandInDescriptor&, // descriptor

Derek Lamberti

013c390

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

[diff] [blame]

586

Optional<std::string&> reasonIfUnsupported) const

587

{

588

if (reasonIfUnsupported)

589

{

590

std::stringstream message;

591

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

592

593

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

}

return false;

}

Teresa Charlin

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

[diff] [blame]

599

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

600

const TensorInfo&, // output

601

const StridedSliceDescriptor&, // descriptor

Matteo Martincigh

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

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

608

const TensorInfo&, // input1

609

const TensorInfo&, // output

Matteo Martincigh

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

[diff] [blame]

610

Optional<std::string&> reasonIfUnsupported) const

611

{

612

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

613

}

614

Teresa Charlin

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

[diff] [blame]

615

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

616

const TensorInfo&, // input1

617

const TensorInfo&, // output0

618

const TensorInfo&, // output1

Sadik Armagan

eff363d

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

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

625

const TensorInfo&, // output

626

const TransposeConvolution2dDescriptor&, // descriptor

627

const TensorInfo&, // weights

628

const Optional<TensorInfo>&, // biases

Aron Virginas-Tar

639fb04

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

[diff] [blame]

629

Optional<std::string&> reasonIfUnsupported) const

630

{

631

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

Teresa Charlin

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

[diff] [blame]

632

}

Aron Virginas-Tar

639fb04

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

[diff] [blame]

633

Teresa Charlin

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

[diff] [blame]

634

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

635

const TensorInfo&, // output

636

const TransposeDescriptor&, // descriptor

Mike Kelly

c9ea45a

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

[diff] [blame]

637

Optional<std::string&> reasonIfUnsupported) const

638

{

639

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

640

}

641

Matteo Martincigh