Blame - src/backends/neon/NeonLayerSupport.hpp - ml/armnn

telsoa01

4fcda01

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

[diff] [blame]

1

//

Keith Davis

69e653f

2020-07-02 11:49:26 +0100

[diff] [blame]

2

David Beck

ecb56cd

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

[diff] [blame]

3

// SPDX-License-Identifier: MIT

telsoa01

4fcda01

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

[diff] [blame]

//

#pragma once

Sadik Armagan

2020-09-10 13:37:32 +0100

[diff] [blame]

7

#include <armnn/backends/IBackendInternal.hpp>

8

Matteo Martincigh

992d6dc

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

[diff] [blame]

9

#include <backendsCommon/LayerSupportBase.hpp>

telsoa01

4fcda01

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

[diff] [blame]

namespace armnn

{

Matteo Martincigh

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

[diff] [blame]

14

class NeonLayerSupport : public LayerSupportBase

arovir01

4424b0a

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

[diff] [blame]

15

{

arovir01

7ff76c5

2018-10-09 09:40:58 +0100

[diff] [blame]

16

public:

Sadik Armagan

045f6be

2020-09-10 13:37:32 +0100

[diff] [blame]

17

explicit NeonLayerSupport(const IBackendInternal::IBackendSpecificModelContextPtr& modelContextPtr);

18

NeonLayerSupport();

19

20

~NeonLayerSupport() {}

21

josh minor

4a3c610

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

[diff] [blame]

22

ARMNN_DEPRECATED_MSG("Use IsElementwiseUnarySupported instead")

Aron Virginas-Tar

914e4db

2019-09-09 13:36:45 +0100

[diff] [blame]

23

bool IsAbsSupported(const TensorInfo& input,

24

const TensorInfo& output,

25

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

26

arovir01

7ff76c5

2018-10-09 09:40:58 +0100

[diff] [blame]

27

bool IsActivationSupported(const TensorInfo& input,

28

const TensorInfo& output,

29

const ActivationDescriptor& descriptor,

30

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

31

32

bool IsAdditionSupported(const TensorInfo& input0,

33

const TensorInfo& input1,

34

const TensorInfo& output,

35

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

36

James Conroy

d47a064

2019-09-17 14:22:06 +0100

[diff] [blame]

37

bool IsArgMinMaxSupported(const TensorInfo& input,

38

const TensorInfo& output,

39

const ArgMinMaxDescriptor& descriptor,

40

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

41

arovir01

7ff76c5

2018-10-09 09:40:58 +0100

[diff] [blame]

42

bool IsBatchNormalizationSupported(const TensorInfo& input,

43

const TensorInfo& output,

44

const TensorInfo& mean,

45

const TensorInfo& var,

46

const TensorInfo& beta,

47

const TensorInfo& gamma,

48

const BatchNormalizationDescriptor& descriptor,

49

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

50

Mike Kelly

5685802

2020-01-27 12:14:47 +0000

[diff] [blame]

51

bool IsBatchToSpaceNdSupported(const TensorInfo& input,

52

const TensorInfo& output,

53

const BatchToSpaceNdDescriptor& descriptor,

54

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

55

Sadik Armagan

48f011e

2021-04-21 10:50:34 +0100

[diff] [blame]

56

bool IsCastSupported(const TensorInfo& input,

57

const TensorInfo& output,

58

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

59

Teresa Charlin

e89dd69

2021-09-01 16:30:34 +0100

[diff] [blame]

60

bool IsChannelShuffleSupported(const TensorInfo& input,

61

const TensorInfo& output,

62

const ChannelShuffleDescriptor& descriptor,

63

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

64

Aron Virginas-Tar

77bfb5e

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

[diff] [blame]

65

bool IsComparisonSupported(const TensorInfo& input0,

66

const TensorInfo& input1,

67

const TensorInfo& output,

68

const ComparisonDescriptor& descriptor,

69

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

70

Jim Flynn

906f946

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

[diff] [blame]

71

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

72

const TensorInfo& output,

Jim Flynn

e242f2d

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

[diff] [blame]

73

const ConcatDescriptor& descriptor,

Jim Flynn

906f946

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

[diff] [blame]

74

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

75

arovir01

7ff76c5

2018-10-09 09:40:58 +0100

[diff] [blame]

76

bool IsConstantSupported(const TensorInfo& output,

77

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

78

Narumol Prangnawarat

250d392

2020-03-30 16:11:04 +0100

[diff] [blame]

79

bool IsConvertBf16ToFp32Supported(const TensorInfo& input,

80

const TensorInfo& output,

81

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

82

arovir01

7ff76c5

2018-10-09 09:40:58 +0100

[diff] [blame]

83

bool IsConvertFp16ToFp32Supported(const TensorInfo& input,

84

const TensorInfo& output,

85

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

86

Narumol Prangnawarat

250d392

2020-03-30 16:11:04 +0100

[diff] [blame]

87

bool IsConvertFp32ToBf16Supported(const TensorInfo& input,

88

const TensorInfo& output,

89

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

90

arovir01

7ff76c5

2018-10-09 09:40:58 +0100

[diff] [blame]

91

bool IsConvertFp32ToFp16Supported(const TensorInfo& input,

92

const TensorInfo& output,

93

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

94

95

bool IsConvolution2dSupported(const TensorInfo& input,

96

const TensorInfo& output,

97

const Convolution2dDescriptor& descriptor,

98

const TensorInfo& weights,

99

const Optional<TensorInfo>& biases,

100

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

101

Aron Virginas-Tar

2f00b74

2019-09-30 13:28:08 +0100

[diff] [blame]

102

bool IsDepthToSpaceSupported(const TensorInfo& input,

103

const TensorInfo& output,

104

const DepthToSpaceDescriptor& descriptor,

105

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

106

107

arovir01

7ff76c5

2018-10-09 09:40:58 +0100

[diff] [blame]

108

bool IsDepthwiseConvolutionSupported(const TensorInfo& input,

109

const TensorInfo& output,

110

const DepthwiseConvolution2dDescriptor& descriptor,

111

const TensorInfo& weights,

112

const Optional<TensorInfo>& biases,

113

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

114

Narumol Prangnawarat

01961a7

2019-05-30 16:47:12 +0100

[diff] [blame]

115

bool IsDequantizeSupported(const TensorInfo& input,

116

const TensorInfo& output,

117

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

118

Pablo Tello

f0bd683

2019-04-26 17:58:13 +0100

[diff] [blame]

119

bool IsDilatedDepthwiseConvolutionSupported(const TensorInfo& input,

120

const TensorInfo& output,

121

const DepthwiseConvolution2dDescriptor& descriptor,

122

const TensorInfo& weights,

123

const Optional<TensorInfo>& biases,

124

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

125

josh minor

4a3c610

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

[diff] [blame]

126

bool IsElementwiseUnarySupported(const TensorInfo& input,

127

const TensorInfo& output,

128

const ElementwiseUnaryDescriptor& descriptor,

129

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

130

Sadik Armagan

a792a05

2020-06-23 16:22:23 +0100

[diff] [blame]

131

bool IsFillSupported(const TensorInfo& input,

132

const TensorInfo& output,

133

const FillDescriptor& descriptor,

134

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

135

arovir01

7ff76c5

2018-10-09 09:40:58 +0100

[diff] [blame]

136

bool IsFloorSupported(const TensorInfo& input,

137

const TensorInfo& output,

138

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

139

140

bool IsFullyConnectedSupported(const TensorInfo& input,

141

const TensorInfo& output,

142

const TensorInfo& weights,

143

const TensorInfo& biases,

144

const FullyConnectedDescriptor& descriptor,

145

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

146

Teresa Charlin

f540eb8

2020-04-10 19:24:55 +0100

[diff] [blame]

147

bool IsGatherSupported(const TensorInfo& input0,

148

const TensorInfo& input1,

149

const TensorInfo& output,

Teresa Charlin

5266473

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

[diff] [blame]

150

const GatherDescriptor& descriptor,

Teresa Charlin

f540eb8

2020-04-10 19:24:55 +0100

[diff] [blame]

151

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

152

Aron Virginas-Tar

77bfb5e

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

[diff] [blame]

153

ARMNN_DEPRECATED_MSG("Use IsComparisonSupported instead")

kevmay01

eed8592

2019-01-28 08:37:25 +0000

[diff] [blame]

154

bool IsGreaterSupported(const TensorInfo& input0,

155

const TensorInfo& input1,

156

const TensorInfo& output,

157

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

158

arovir01

7ff76c5

2018-10-09 09:40:58 +0100

[diff] [blame]

159

bool IsInputSupported(const TensorInfo& input,

160

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

161

Sadik Armagan

0d4863d

2019-10-09 14:26:32 +0100

[diff] [blame]

162

bool IsInstanceNormalizationSupported(const TensorInfo& input,

163

const TensorInfo& output,

164

const InstanceNormalizationDescriptor& descriptor,

165

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

166

arovir01

7ff76c5

2018-10-09 09:40:58 +0100

[diff] [blame]

167

bool IsL2NormalizationSupported(const TensorInfo& input,

168

const TensorInfo& output,

169

const L2NormalizationDescriptor& descriptor,

170

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

171

James Conroy

177df1e

2020-11-13 10:18:51 +0000

[diff] [blame]

172

bool IsLogicalBinarySupported(const TensorInfo& input0,

173

const TensorInfo& input1,

174

const TensorInfo& output,

175

const LogicalBinaryDescriptor& descriptor,

176

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

177

Keith Davis

69e653f

2020-07-02 11:49:26 +0100

[diff] [blame]

178

bool IsLogSoftmaxSupported(const TensorInfo& input,

179

const TensorInfo& output,

180

const LogSoftmaxDescriptor& descriptor,

181

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

182

Jan Eilers

ad5293a

2019-07-08 09:57:55 +0100

[diff] [blame]

183

bool IsLstmSupported(const TensorInfo& input,

184

const TensorInfo& outputStateIn,

185

const TensorInfo& cellStateIn,

186

const TensorInfo& scratchBuffer,

187

const TensorInfo& outputStateOut,

188

const TensorInfo& cellStateOut,

189

const TensorInfo& output,

190

const LstmDescriptor& descriptor,

191

const LstmInputParamsInfo& paramsInfo,

192

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

193

Nattapat Chaimanowong

4e6597a

2018-12-20 14:14:06 +0000

[diff] [blame]

194

bool IsMaximumSupported(const TensorInfo& input0,

195

const TensorInfo& input1,

196

const TensorInfo& output,

197

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

198

arovir01

7ff76c5

2018-10-09 09:40:58 +0100

[diff] [blame]

199

bool IsMeanSupported(const TensorInfo& input,

200

const TensorInfo& output,

201

const MeanDescriptor& descriptor,

202

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

203

Jim Flynn

906f946

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

[diff] [blame]

204

ARMNN_DEPRECATED_MSG("Use IsConcatSupported instead")

arovir01

7ff76c5

2018-10-09 09:40:58 +0100

[diff] [blame]

205

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

Nikhil Raj

8599a41

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

[diff] [blame]

206

const TensorInfo& output,

Jim Flynn

e242f2d

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

[diff] [blame]

207

const MergerDescriptor& descriptor,

arovir01

7ff76c5

2018-10-09 09:40:58 +0100

[diff] [blame]

208

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

209

Conor Kennedy

54b2169

2019-01-09 07:57:38 +0000

[diff] [blame]

210

bool IsMinimumSupported(const TensorInfo& input0,

211

const TensorInfo& input1,

212

const TensorInfo& output,

213

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

214

arovir01

7ff76c5

2018-10-09 09:40:58 +0100

[diff] [blame]

215

bool IsMultiplicationSupported(const TensorInfo& input0,

216

const TensorInfo& input1,

217

const TensorInfo& output,

218

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

219

Pablo Tello

e61f071

2020-01-23 10:37:17 +0000

[diff] [blame]

220

bool IsDivisionSupported(const TensorInfo& input0,

221

const TensorInfo& input1,

222

const TensorInfo& output,

223

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

224

arovir01

7ff76c5

2018-10-09 09:40:58 +0100

[diff] [blame]

225

bool IsNormalizationSupported(const TensorInfo& input,

226

const TensorInfo& output,

227

const NormalizationDescriptor& descriptor,

228

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

229

230

bool IsOutputSupported(const TensorInfo& output,

231

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

232

Éanna Ó Catháin

1205574

2019-01-25 10:01:40 +0000

[diff] [blame]

233

bool IsPadSupported(const TensorInfo& input,

234

const TensorInfo& output,

235

const PadDescriptor& descriptor,

236

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

237

arovir01

7ff76c5

2018-10-09 09:40:58 +0100

[diff] [blame]

238

bool IsPermuteSupported(const TensorInfo& input,

239

const TensorInfo& output,

240

const PermuteDescriptor& descriptor,

241

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

242

243

bool IsPooling2dSupported(const TensorInfo& input,

244

const TensorInfo& output,

245

const Pooling2dDescriptor& descriptor,

246

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

247

Nikhil Raj

9b46148

2019-07-03 15:58:31 +0100

[diff] [blame]

248

bool IsPreluSupported(const TensorInfo& input,

249

const TensorInfo& alpha,

250

const TensorInfo& output,

251

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

252

James Conroy

cc34093

2020-05-12 18:08:52 +0100

[diff] [blame]

253

bool IsQLstmSupported(const TensorInfo& input,

254

const TensorInfo& previousOutputIn,

255

const TensorInfo& previousCellStateIn,

256

const TensorInfo& outputStateOut,

257

const TensorInfo& cellStateOut,

258

const TensorInfo& output,

259

const QLstmDescriptor& descriptor,

260

const LstmInputParamsInfo& paramsInfo,

261

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

262

Sadik Armagan

fabc289

2019-05-31 09:05:11 +0100

[diff] [blame]

263

bool IsQuantizeSupported(const TensorInfo& input,

264

const TensorInfo& output,

265

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

266

Francis Murtagh

4fc3c48

2019-08-02 13:20:54 +0100

[diff] [blame]

267

bool IsQuantizedLstmSupported(const TensorInfo& input,

268

const TensorInfo& cellStateIn,

269

const TensorInfo& outputStateIn,

270

const TensorInfo& cellStateOut,

271

const TensorInfo& outputStateOut,

272

const QuantizedLstmInputParamsInfo& paramsInfo,

273

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

274

Sadik Armagan

a274748

2021-02-09 10:28:54 +0000

[diff] [blame]

275

bool IsReduceSupported(const TensorInfo& input,

276

const TensorInfo& output,

277

const ReduceDescriptor& descriptor,

278

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

279

arovir01

7ff76c5

2018-10-09 09:40:58 +0100

[diff] [blame]

280

bool IsReshapeSupported(const TensorInfo& input,

Kevin May

a023c40

2019-12-12 17:28:05 +0000

[diff] [blame]

281

const TensorInfo& output,

Matteo Martincigh

992d6dc

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

[diff] [blame]

282

const ReshapeDescriptor& descriptor,

arovir01

7ff76c5

2018-10-09 09:40:58 +0100

[diff] [blame]

283

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

284

Aron Virginas-Tar

169d2f1

2019-07-01 19:01:44 +0100

[diff] [blame]

285

bool IsResizeSupported(const TensorInfo& input,

286

const TensorInfo& output,

287

const ResizeDescriptor& descriptor,

288

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

289

290

ARMNN_DEPRECATED_MSG("Use IsResizeSupported instead")

Sadik Armagan

c625f00

2018-12-17 11:32:16 +0000

[diff] [blame]

291

bool IsResizeBilinearSupported(const TensorInfo& input,

292

const TensorInfo& output,

293

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

294

josh minor

4a3c610

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

[diff] [blame]

295

ARMNN_DEPRECATED_MSG("Use IsElementwiseUnarySupported instead")

Aron Virginas-Tar

0dd3b43

2019-09-10 13:55:09 +0100

[diff] [blame]

296

bool IsRsqrtSupported(const TensorInfo& input,

297

const TensorInfo& output,

298

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

299

josh minor

036f02d

2019-11-15 14:53:22 -0600

[diff] [blame]

300

bool IsSliceSupported(const TensorInfo& input,

301

const TensorInfo& output,

302

const SliceDescriptor& descriptor,

303

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

304

arovir01

7ff76c5

2018-10-09 09:40:58 +0100

[diff] [blame]

305

bool IsSoftmaxSupported(const TensorInfo& input,

306

const TensorInfo& output,

307

const SoftmaxDescriptor& descriptor,

308

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

309

Mike Kelly

0be3a88

2020-01-24 11:27:50 +0000

[diff] [blame]

310

bool IsSpaceToBatchNdSupported(const TensorInfo& input,

311

const TensorInfo& output,

312

const SpaceToBatchNdDescriptor& descriptor,

313

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

314

Ellen Norris-Thompson

2979457

2019-06-26 16:40:36 +0100

[diff] [blame]

315

bool IsSpaceToDepthSupported(const TensorInfo& input,

316

const TensorInfo& output,

317

const SpaceToDepthDescriptor& descriptor,

318

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

319

Narumol Prangnawarat

15eb583

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

[diff] [blame]

320

ARMNN_DEPRECATED_MSG("Use IsSplitterSupported with outputs instead")

arovir01

7ff76c5

2018-10-09 09:40:58 +0100

[diff] [blame]

321

bool IsSplitterSupported(const TensorInfo& input,

322

const ViewsDescriptor& descriptor,

323

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

324

Narumol Prangnawarat

15eb583

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

[diff] [blame]

325

bool IsSplitterSupported(const TensorInfo& input,

326

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

327

const ViewsDescriptor& descriptor,

328

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

329

Matthew Jackson

87f65ea

2019-08-01 10:01:34 +0100

[diff] [blame]

330

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

331

const TensorInfo& output,

332

const StackDescriptor& descriptor,

333

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

334

FinnWilliamsArm

1fa1919

2019-08-02 17:26:31 +0100

[diff] [blame]

335

bool IsStridedSliceSupported(const TensorInfo& input,

336

const TensorInfo& output,

337

const StridedSliceDescriptor& descriptor,

338

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

339

arovir01

7ff76c5

2018-10-09 09:40:58 +0100

[diff] [blame]

340

bool IsSubtractionSupported(const TensorInfo& input0,

341

const TensorInfo& input1,

342

const TensorInfo& output,

343

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

Sadik Armagan

581742d

2019-08-12 14:11:37 +0100

[diff] [blame]

344

345

bool IsTransposeConvolution2dSupported(const TensorInfo& input,

346

const TensorInfo& output,

347

const TransposeConvolution2dDescriptor& descriptor,

348

const TensorInfo& weights,

349

const Optional<TensorInfo>& biases,

350

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

351

Mike Kelly

c9ea45a

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

[diff] [blame]

352

bool IsTransposeSupported(const TensorInfo& input,

353

const TensorInfo& output,

354

const TransposeDescriptor& descriptor,

355

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

356

Sadik Armagan

045f6be

2020-09-10 13:37:32 +0100

[diff] [blame]

357

private:

358

const IBackendInternal::IBackendSpecificModelContextPtr m_ModelContextPtr;

359

Aron Virginas-Tar

fc82431

2018-10-15 15:00:13 +0100

[diff] [blame]

360

}; // class NeonLayerSupport

arovir01

4424b0a

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

[diff] [blame]

361

arovir01

7ff76c5

2018-10-09 09:40:58 +0100

[diff] [blame]

362

} // namespace armnn