Blame - src/backends/cl/ClLayerSupport.hpp - ml/armnn

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

[diff] [blame]

1

//

2

David Beck

ecb56cd

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

[diff] [blame]

3

// SPDX-License-Identifier: MIT

telsoa01

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

[diff] [blame]

//

#pragma once

telsoa01

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

[diff] [blame]

7

#include <armnn/ArmNN.hpp>

telsoa01

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

[diff] [blame]

8

9

namespace armnn

10

{

arovir01

4424b0a

2018-10-04 10:46:04 +0100

[diff] [blame]

11

12

class ClLayerSupport : public ILayerSupport

13

{

arovir01

7c22c70

2018-10-09 11:16:46 +0100

[diff] [blame^]

14

public:

15

bool IsActivationSupported(const TensorInfo& input,

16

const TensorInfo& output,

17

const ActivationDescriptor& descriptor,

18

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

19

20

bool IsAdditionSupported(const TensorInfo& input0,

21

const TensorInfo& input1,

22

const TensorInfo& output,

23

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

24

25

bool IsBatchNormalizationSupported(const TensorInfo& input,

26

const TensorInfo& output,

27

const TensorInfo& mean,

28

const TensorInfo& var,

29

const TensorInfo& beta,

30

const TensorInfo& gamma,

31

const BatchNormalizationDescriptor& descriptor,

32

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

33

34

bool IsConstantSupported(const TensorInfo& output,

35

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

36

37

bool IsConvertFp16ToFp32Supported(const TensorInfo& input,

38

const TensorInfo& output,

39

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

40

41

bool IsConvertFp32ToFp16Supported(const TensorInfo& input,

42

const TensorInfo& output,

43

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

44

45

bool IsConvolution2dSupported(const TensorInfo& input,

46

const TensorInfo& output,

47

const Convolution2dDescriptor& descriptor,

48

const TensorInfo& weights,

49

const Optional<TensorInfo>& biases,

50

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

51

52

bool IsDepthwiseConvolutionSupported(const TensorInfo& input,

53

const TensorInfo& output,

54

const DepthwiseConvolution2dDescriptor& descriptor,

55

const TensorInfo& weights,

56

const Optional<TensorInfo>& biases,

57

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

58

59

bool IsDivisionSupported(const TensorInfo& input0,

60

const TensorInfo& input1,

61

const TensorInfo& output,

62

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

63

64

bool IsFakeQuantizationSupported(const TensorInfo& input,

65

const FakeQuantizationDescriptor& descriptor,

66

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

67

68

bool IsFloorSupported(const TensorInfo& input,

69

const TensorInfo& output,

70

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

71

72

bool IsFullyConnectedSupported(const TensorInfo& input,

73

const TensorInfo& output,

74

const TensorInfo& weights,

75

const TensorInfo& biases,

76

const FullyConnectedDescriptor& descriptor,

77

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

78

79

bool IsInputSupported(const TensorInfo& input,

80

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

81

82

bool IsL2NormalizationSupported(const TensorInfo& input,

83

const TensorInfo& output,

84

const L2NormalizationDescriptor& descriptor,

85

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

86

87

bool IsLstmSupported(const TensorInfo& input,

88

const TensorInfo& outputStateIn,

89

const TensorInfo& cellStateIn,

90

const TensorInfo& scratchBuffer,

91

const TensorInfo& outputStateOut,

92

const TensorInfo& cellStateOut,

93

const TensorInfo& output,

94

const LstmDescriptor& descriptor,

95

const TensorInfo& inputToForgetWeights,

96

const TensorInfo& inputToCellWeights,

97

const TensorInfo& inputToOutputWeights,

98

const TensorInfo& recurrentToForgetWeights,

99

const TensorInfo& recurrentToCellWeights,

100

const TensorInfo& recurrentToOutputWeights,

101

const TensorInfo& forgetGateBias,

102

const TensorInfo& cellBias,

103

const TensorInfo& outputGateBias,

104

const TensorInfo* inputToInputWeights,

105

const TensorInfo* recurrentToInputWeights,

106

const TensorInfo* cellToInputWeights,

107

const TensorInfo* inputGateBias,

108

const TensorInfo* projectionWeights,

109

const TensorInfo* projectionBias,

110

const TensorInfo* cellToForgetWeights,

111

const TensorInfo* cellToOutputWeights,

112

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

113

114

bool IsMeanSupported(const TensorInfo& input,

115

const TensorInfo& output,

116

const MeanDescriptor& descriptor,

117

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

118

119

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

120

const OriginsDescriptor& descriptor,

121

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

122

123

bool IsMultiplicationSupported(const TensorInfo& input0,

124

const TensorInfo& input1,

125

const TensorInfo& output,

126

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

127

128

bool IsNormalizationSupported(const TensorInfo& input,

129

const TensorInfo& output,

130

const NormalizationDescriptor& descriptor,

131

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

132

133

bool IsOutputSupported(const TensorInfo& output,

134

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

135

136

bool IsPadSupported(const TensorInfo& input,

137

const TensorInfo& output,

138

const PadDescriptor& descriptor,

139

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

140

141

bool IsPermuteSupported(const TensorInfo& input,

142

const TensorInfo& output,

143

const PermuteDescriptor& descriptor,

144

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

145

146

bool IsPooling2dSupported(const TensorInfo& input,

147

const TensorInfo& output,

148

const Pooling2dDescriptor& descriptor,

149

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

150

151

bool IsReshapeSupported(const TensorInfo& input,

152

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

153

154

bool IsResizeBilinearSupported(const TensorInfo& input,

155

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

156

157

bool IsSoftmaxSupported(const TensorInfo& input,

158

const TensorInfo& output,

159

const SoftmaxDescriptor& descriptor,

160

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

161

162

bool IsSplitterSupported(const TensorInfo& input,

163

const ViewsDescriptor& descriptor,

164

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

165

166

bool IsSubtractionSupported(const TensorInfo& input0,

167

const TensorInfo& input1,

168

const TensorInfo& output,

169

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

arovir01

4424b0a

2018-10-04 10:46:04 +0100

[diff] [blame]

170

};

171

telsoa01

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

[diff] [blame]

172

bool IsClDirectConvolution2dSupported(const TensorInfo& weightInfo, const Convolution2dDescriptor& desc);

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

173

bool IsClDepthwiseConvolution2dDescParamsSupported(Optional<std::string&> reasonIfUnsupported,

telsoa01

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

[diff] [blame]

174

const DepthwiseConvolution2dDescriptor& parameters,

175

const TensorInfo& weights);

176

177

bool IsActivationSupportedCl(const TensorInfo& input,

telsoa01

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

[diff] [blame]

178

const TensorInfo& output,

telsoa01

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

[diff] [blame]

179

const ActivationDescriptor& descriptor,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

180

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

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

[diff] [blame]

181

182

bool IsAdditionSupportedCl(const TensorInfo& input0,

183

const TensorInfo& input1,

184

const TensorInfo& output,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

185

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

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

[diff] [blame]

186

187

bool IsBatchNormalizationSupportedCl(const TensorInfo& input,

telsoa01

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

[diff] [blame]

188

const TensorInfo& output,

189

const TensorInfo& mean,

190

const TensorInfo& var,

191

const TensorInfo& beta,

192

const TensorInfo& gamma,

telsoa01

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

[diff] [blame]

193

const BatchNormalizationDescriptor& descriptor,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

194

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

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

[diff] [blame]

195

196

bool IsConstantSupportedCl(const TensorInfo& output,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

197

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

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

[diff] [blame]

198

199

bool IsConvolution2dSupportedCl(const TensorInfo& input,

surmeh01

3537c2c

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

[diff] [blame]

200

const TensorInfo& output,

telsoa01

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

[diff] [blame]

201

const Convolution2dDescriptor& descriptor,

202

const TensorInfo& weights,

David Beck

5eec11d

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

[diff] [blame]

203

const Optional<TensorInfo>& biases,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

204

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

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

[diff] [blame]

205

206

bool IsDepthwiseConvolutionSupportedCl(const TensorInfo& input,

telsoa01

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

[diff] [blame]

207

const TensorInfo& output,

telsoa01

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

[diff] [blame]

208

const DepthwiseConvolution2dDescriptor& descriptor,

209

const TensorInfo& weights,

David Beck

5eec11d

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

[diff] [blame]

210

const Optional<TensorInfo>& biases,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

211

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

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

[diff] [blame]

212

Francis Murtagh

e7a86a4

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

[diff] [blame]

213

bool IsDivisionSupportedCl(const TensorInfo& input0,

214

const TensorInfo& input1,

215

const TensorInfo& output,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

216

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

Francis Murtagh

e7a86a4

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

[diff] [blame]

217

David Beck

c2044fe

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

[diff] [blame]

218

bool IsSubtractionSupportedCl(const TensorInfo& input0,

219

const TensorInfo& input1,

220

const TensorInfo& output,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

221

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

David Beck

c2044fe

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

[diff] [blame]

222

telsoa01

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

[diff] [blame]

223

bool IsFullyConnectedSupportedCl(const TensorInfo& input,

telsoa01

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

[diff] [blame]

224

const TensorInfo& output,

225

const TensorInfo& weights,

226

const TensorInfo& biases,

telsoa01

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

[diff] [blame]

227

const FullyConnectedDescriptor& descriptor,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

228

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

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

[diff] [blame]

229

230

bool IsInputSupportedCl(const TensorInfo& input,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

231

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

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

[diff] [blame]

232

233

bool IsL2NormalizationSupportedCl(const TensorInfo& input,

telsoa01

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

[diff] [blame]

234

const TensorInfo& output,

Matteo Martincigh

bcd3c85

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

[diff] [blame]

235

const L2NormalizationDescriptor& descriptor,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

236

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

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

[diff] [blame]

237

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

238

bool IsLstmSupportedCl(const TensorInfo& input,

239

const TensorInfo& outputStateIn,

240

const TensorInfo& cellStateIn,

241

const TensorInfo& scratchBuffer,

242

const TensorInfo& outputStateOut,

243

const TensorInfo& cellStateOut,

244

const TensorInfo& output,

245

const LstmDescriptor& descriptor,

246

const TensorInfo& inputToForgetWeights,

247

const TensorInfo& inputToCellWeights,

248

const TensorInfo& inputToOutputWeights,

249

const TensorInfo& recurrentToForgetWeights,

250

const TensorInfo& recurrentToCellWeights,

251

const TensorInfo& recurrentToOutputWeights,

252

const TensorInfo& forgetGateBias,

253

const TensorInfo& cellBias,

254

const TensorInfo& outputGateBias,

255

const TensorInfo* inputToInputWeights,

256

const TensorInfo* recurrentToInputWeights,

257

const TensorInfo* cellToInputWeights,

258

const TensorInfo* inputGateBias,

259

const TensorInfo* projectionWeights,

260

const TensorInfo* projectionBias,

261

const TensorInfo* cellToForgetWeights,

262

const TensorInfo* cellToOutputWeights,

263

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

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

[diff] [blame]

264

telsoa01

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

[diff] [blame]

265

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

266

const OriginsDescriptor& descriptor,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

267

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

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

[diff] [blame]

268

269

bool IsMultiplicationSupportedCl(const TensorInfo& input0,

270

const TensorInfo& input1,

telsoa01

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

[diff] [blame]

271

const TensorInfo& output,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

272

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

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

[diff] [blame]

273

274

bool IsNormalizationSupportedCl(const TensorInfo& input,

275

const TensorInfo& output,

276

const NormalizationDescriptor& descriptor,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

277

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

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

[diff] [blame]

278

279

bool IsOutputSupportedCl(const TensorInfo& output,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

280

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

jimfly01

e1fa50c

2018-09-21 12:09:51 +0100

[diff] [blame]

281

telsoa01

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

[diff] [blame]

282

bool IsPermuteSupportedCl(const TensorInfo& input,

283

const TensorInfo& output,

284

const PermuteDescriptor& descriptor,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

285

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

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

[diff] [blame]

286

287

bool IsPooling2dSupportedCl(const TensorInfo& input,

288

const TensorInfo& output,

289

const Pooling2dDescriptor& descriptor,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

290

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

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

[diff] [blame]

291

292

bool IsResizeBilinearSupportedCl(const TensorInfo& input,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

293

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

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

[diff] [blame]

294

295

bool IsSoftmaxSupportedCl(const TensorInfo& input,

telsoa01

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

[diff] [blame]

296

const TensorInfo& output,

telsoa01

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

[diff] [blame]

297

const SoftmaxDescriptor& descriptor,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

298

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

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

[diff] [blame]

299

300

bool IsSplitterSupportedCl(const TensorInfo& input,

301

const ViewsDescriptor& descriptor,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

302

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

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

[diff] [blame]

303

304

bool IsFakeQuantizationSupportedCl(const TensorInfo& input,

305

const FakeQuantizationDescriptor& descriptor,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

306

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

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

[diff] [blame]

307

308

bool IsReshapeSupportedCl(const TensorInfo& input,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

309

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

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

[diff] [blame]

310

311

bool IsFloorSupportedCl(const TensorInfo& input,

312

const TensorInfo& output,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

313

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

314

315

bool IsConvertFp16ToFp32SupportedCl(const TensorInfo& input,

316

const TensorInfo& output,

317

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

318

319

bool IsConvertFp32ToFp16SupportedCl(const TensorInfo& input,

320

const TensorInfo& output,

321

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

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

[diff] [blame]

322

narpra01

32b9046

2018-09-13 11:07:48 +0100

[diff] [blame]

323

bool IsMeanSupportedCl(const TensorInfo& input,

324

const TensorInfo& output,

325

const MeanDescriptor& descriptor,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

326

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

narpra01

32b9046

2018-09-13 11:07:48 +0100

[diff] [blame]

327

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

328

bool IsPadSupportedCl(const TensorInfo& input,

329

const TensorInfo& output,

330

const PadDescriptor& descriptor,

331

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

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

[diff] [blame]

332

telsoa01