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

2018-10-03 13:09:28 +0100

[diff] [blame]

1

//

2

3

// SPDX-License-Identifier: MIT

4

//

5

6

#include <armnn/ILayerSupport.hpp>

David Beck

3cc9a62

2018-10-12 10:38:31 +0100

[diff] [blame]

7

#include <armnn/Exceptions.hpp>

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

namespace armnn

{

namespace

{

bool DefaultLayerSupport(const char* func,

16

const char* file,

17

unsigned int line,

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

18

Optional<std::string&> reasonIfUnsupported)

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

19

{

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

20

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

21

if (reasonIfUnsupported)

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

22

{

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

23

std::stringstream message;

24

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

25

26

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

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

27

}

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

28

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

return false;

}

arovir01

2018-10-08 12:01:04 +0100

[diff] [blame]

32

} // anonymous namespace

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

33

34

bool ILayerSupport::IsActivationSupported(const TensorInfo& input,

35

const TensorInfo& output,

36

const ActivationDescriptor& descriptor,

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

37

Optional<std::string&> reasonIfUnsupported) const

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

38

{

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

39

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

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

40

}

41

42

bool ILayerSupport::IsAdditionSupported(const TensorInfo& input0,

43

const TensorInfo& input1,

44

const TensorInfo& output,

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

45

Optional<std::string&> reasonIfUnsupported) const

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

46

{

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

47

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

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

48

}

49

50

bool ILayerSupport::IsBatchNormalizationSupported(const TensorInfo& input,

51

const TensorInfo& output,

52

const TensorInfo& mean,

53

const TensorInfo& var,

54

const TensorInfo& beta,

55

const TensorInfo& gamma,

56

const BatchNormalizationDescriptor& descriptor,

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

57

Optional<std::string&> reasonIfUnsupported) const

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

58

{

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

59

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

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

60

}

61

Éanna Ó Catháin

4e1e136

2018-11-12 11:36:34 +0000

[diff] [blame]

62

bool ILayerSupport::IsBatchToSpaceNdSupported(const TensorInfo& input,

63

const TensorInfo& output,

64

const BatchToSpaceNdDescriptor& descriptor,

65

Optional<std::string&> reasonIfUnsupported) const

66

{

67

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

68

}

69

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

70

bool ILayerSupport::IsConstantSupported(const TensorInfo& output,

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

71

Optional<std::string&> reasonIfUnsupported) const

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

72

{

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

73

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

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

74

}

75

76

bool ILayerSupport::IsConvertFp16ToFp32Supported(const TensorInfo& input,

77

const TensorInfo& output,

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

78

Optional<std::string&> reasonIfUnsupported) const

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

79

{

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

80

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

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

81

}

82

83

bool ILayerSupport::IsConvertFp32ToFp16Supported(const TensorInfo& input,

84

const TensorInfo& output,

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

85

Optional<std::string&> reasonIfUnsupported) const

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

86

{

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

87

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

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

88

}

89

90

bool ILayerSupport::IsConvolution2dSupported(const TensorInfo& input,

91

const TensorInfo& output,

92

const Convolution2dDescriptor& descriptor,

93

const TensorInfo& weights,

David Beck

5eec11d

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

[diff] [blame]

94

const Optional<TensorInfo>& biases,

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

95

Optional<std::string&> reasonIfUnsupported) const

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

96

{

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

97

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

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

98

}

99

100

bool ILayerSupport::IsDepthwiseConvolutionSupported(const TensorInfo& input,

101

const TensorInfo& output,

102

const DepthwiseConvolution2dDescriptor& descriptor,

103

const TensorInfo& weights,

David Beck

5eec11d

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

[diff] [blame]

104

const Optional<TensorInfo>& biases,

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

105

Optional<std::string&> reasonIfUnsupported) const

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

106

{

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

107

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

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

108

}

109

110

bool ILayerSupport::IsDivisionSupported(const TensorInfo& input0,

111

const TensorInfo& input1,

112

const TensorInfo& output,

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

113

Optional<std::string&> reasonIfUnsupported) const

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

114

{

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

115

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

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

116

}

117

arovir01

2018-10-08 12:01:04 +0100

[diff] [blame]

118

bool ILayerSupport::IsFakeQuantizationSupported(const TensorInfo& input,

119

const FakeQuantizationDescriptor& descriptor,

120

Optional<std::string&> reasonIfUnsupported) const

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

121

{

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

122

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

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

123

}

124

arovir01

2018-10-08 12:01:04 +0100

[diff] [blame]

125

bool ILayerSupport::IsFloorSupported(const TensorInfo& input,

126

const TensorInfo& output,

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

127

Optional<std::string&> reasonIfUnsupported) const

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

128

{

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

129

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

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

130

}

131

132

bool ILayerSupport::IsFullyConnectedSupported(const TensorInfo& input,

133

const TensorInfo& output,

134

const TensorInfo& weights,

135

const TensorInfo& biases,

136

const FullyConnectedDescriptor& descriptor,

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

137

Optional<std::string&> reasonIfUnsupported) const

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

138

{

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

139

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

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

140

}

141

arovir01

2018-10-08 12:01:04 +0100

[diff] [blame]

142

bool ILayerSupport::IsInputSupported(const TensorInfo& input,

143

Optional<std::string&> reasonIfUnsupported) const

144

{

145

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

146

}

147

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

148

bool ILayerSupport::IsL2NormalizationSupported(const TensorInfo& input,

149

const TensorInfo& output,

150

const L2NormalizationDescriptor& descriptor,

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

151

Optional<std::string&> reasonIfUnsupported) const

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

152

{

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

153

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

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

154

}

155

156

bool ILayerSupport::IsLstmSupported(const TensorInfo& input,

157

const TensorInfo& outputStateIn,

158

const TensorInfo& cellStateIn,

159

const TensorInfo& scratchBuffer,

160

const TensorInfo& outputStateOut,

161

const TensorInfo& cellStateOut,

162

const TensorInfo& output,

163

const LstmDescriptor& descriptor,

164

const TensorInfo& inputToForgetWeights,

165

const TensorInfo& inputToCellWeights,

166

const TensorInfo& inputToOutputWeights,

167

const TensorInfo& recurrentToForgetWeights,

168

const TensorInfo& recurrentToCellWeights,

169

const TensorInfo& recurrentToOutputWeights,

170

const TensorInfo& forgetGateBias,

171

const TensorInfo& cellBias,

172

const TensorInfo& outputGateBias,

173

const TensorInfo* inputToInputWeights,

174

const TensorInfo* recurrentToInputWeights,

175

const TensorInfo* cellToInputWeights,

176

const TensorInfo* inputGateBias,

177

const TensorInfo* projectionWeights,

178

const TensorInfo* projectionBias,

179

const TensorInfo* cellToForgetWeights,

180

const TensorInfo* cellToOutputWeights,

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

181

Optional<std::string&> reasonIfUnsupported) const

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

182

{

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

183

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

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

184

}

185

Nattapat Chaimanowong

5a4304a

2018-11-28 10:44:37 +0000

[diff] [blame]

186

bool ILayerSupport::IsMaximumSupported(const TensorInfo& input0,

187

const TensorInfo& input1,

188

const TensorInfo& output,

189

Optional<std::string&> reasonIfUnsupported) const

190

{

191

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

192

}

193

arovir01

2018-10-08 12:01:04 +0100

[diff] [blame]

194

bool ILayerSupport::IsMeanSupported(const TensorInfo& input,

195

const TensorInfo& output,

196

const MeanDescriptor& descriptor,

197

Optional<std::string&> reasonIfUnsupported) const

198

{

199

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

200

}

201

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

202

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

Nikhil Raj

8599a41

2018-11-19 14:51:07 +0000

[diff] [blame]

203

const TensorInfo& output,

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

204

const OriginsDescriptor& descriptor,

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

205

Optional<std::string&> reasonIfUnsupported) const

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

206

{

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

207

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

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

208

}

209

kevmay01

9053969

2018-11-29 08:40:19 +0000

[diff] [blame^]

210

bool ILayerSupport::IsMinimumSupported(const TensorInfo& input0,

211

const TensorInfo& input1,

212

const TensorInfo& output,

213

Optional<std::string&> reasonIfUnsupported) const

214

{

215

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

216

}

217

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

218

bool ILayerSupport::IsMultiplicationSupported(const TensorInfo& input0,

219

const TensorInfo& input1,

220

const TensorInfo& output,

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

221

Optional<std::string&> reasonIfUnsupported) const

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

222

{

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

223

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

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

224

}

225

226

bool ILayerSupport::IsNormalizationSupported(const TensorInfo& input,

227

const TensorInfo& output,

228

const NormalizationDescriptor& descriptor,

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

229

Optional<std::string&> reasonIfUnsupported) const

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

230

{

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

231

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

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

232

}

233

234

bool ILayerSupport::IsOutputSupported(const TensorInfo& output,

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

235

Optional<std::string&> reasonIfUnsupported) const

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

236

{

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

237

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

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

238

}

239

arovir01

2018-10-08 12:01:04 +0100

[diff] [blame]

240

bool ILayerSupport::IsPadSupported(const TensorInfo& input,

241

const TensorInfo& output,

242

const PadDescriptor& descriptor,

243

Optional<std::string&> reasonIfUnsupported) const

244

{

245

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

246

}

247

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

248

bool ILayerSupport::IsPermuteSupported(const TensorInfo& input,

249

const TensorInfo& output,

250

const PermuteDescriptor& descriptor,

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

251

Optional<std::string&> reasonIfUnsupported) const

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

252

{

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

253

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

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

254

}

255

256

bool ILayerSupport::IsPooling2dSupported(const TensorInfo& input,

257

const TensorInfo& output,

258

const Pooling2dDescriptor& descriptor,

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

259

Optional<std::string&> reasonIfUnsupported) const

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

260

{

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

261

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

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

262

}

263

arovir01

2018-10-08 12:01:04 +0100

[diff] [blame]

264

bool ILayerSupport::IsReshapeSupported(const TensorInfo& input,

265

Optional<std::string&> reasonIfUnsupported) const

266

{

267

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

268

}

269

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

270

bool ILayerSupport::IsResizeBilinearSupported(const TensorInfo& input,

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

271

Optional<std::string&> reasonIfUnsupported) const

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

272

{

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

273

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

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

274

}

275

276

bool ILayerSupport::IsSoftmaxSupported(const TensorInfo& input,

277

const TensorInfo& output,

278

const SoftmaxDescriptor& descriptor,

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

279

Optional<std::string&> reasonIfUnsupported) const

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

280

{

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

281

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

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

282

}

283

Nattapat Chaimanowong

207ef9a

2018-11-02 10:57:25 +0000

[diff] [blame]

284

bool ILayerSupport::IsSpaceToBatchNdSupported(const TensorInfo& input,

285

const TensorInfo& output,

286

const SpaceToBatchNdDescriptor& descriptor,

287

Optional<std::string&> reasonIfUnsupported) const

288

{

289

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

290

}

291

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

292

bool ILayerSupport::IsSplitterSupported(const TensorInfo& input,

293

const ViewsDescriptor& descriptor,

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

294

Optional<std::string&> reasonIfUnsupported) const

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

295

{

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

296

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

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

297

}

298

Conor Kennedy

430b5d8

2018-11-14 15:28:28 +0000

[diff] [blame]

299

bool ILayerSupport::IsStridedSliceSupported(const TensorInfo& input,

300

const TensorInfo& output,

301

const StridedSliceDescriptor& descriptor,

302

Optional<std::string&> reasonIfUnsupported) const

303

{

304

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

305

}

306

arovir01

2018-10-08 12:01:04 +0100

[diff] [blame]

307

bool ILayerSupport::IsSubtractionSupported(const TensorInfo& input0,

308

const TensorInfo& input1,

309

const TensorInfo& output,

310

Optional<std::string&> reasonIfUnsupported) const

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

311

{

arovir01

2018-10-05 15:46:51 +0100

[diff] [blame]

312

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

David Beck

2018-10-03 13:09:28 +0100

[diff] [blame]

313

}

314

arovir01