Blame - tests/validation/NEON/PixelWiseMultiplication.cpp - ml/ComputeLibrary

2017-09-18 16:10:48 +0100

[diff] [blame]

67

#define DEFAULT_VALIDATE validate(Accessor(_target), _reference);

John Richardson

9c450cc

2017-11-22 12:00:41 +0000

[diff] [blame]

68

#define VALIDATE(TYPE, TOLERANCE) validate(Accessor(_target), _reference, AbsoluteTolerance<TYPE>(TOLERANCE), 0.f);

John Richardson

2017-09-18 16:10:48 +0100

[diff] [blame]

69

#define WRAP_VALIDATE(TYPE, TOLERANCE) validate_wrap(Accessor(_target), _reference, AbsoluteTolerance<TYPE>(TOLERANCE), 0.f);

// *INDENT-OFF*

// clang-format off

#define PIXEL_WISE_MULTIPLICATION_DATA_TEST_CASE(DT1, DT2, SCALE, RP) \

74

DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, \

75

combine(combine(combine(combine(combine( \

76

concat(datasets::SmallShapes(), datasets::LargeShapes()), \

77

framework::dataset::make("DataType1", DataType::DT1)), \

78

framework::dataset::make("DataType2", DataType::DT2)), \

79

framework::dataset::make("Scale", std::move(SCALE))), \

80

datasets::ConvertPolicies()), \

81

framework::dataset::make("RoundingPolicy", RoundingPolicy::RP)), \

82

shape, dt1, dt2, scale, convert_policy, rounding_policy) \

83

{ \

84

validate_configuration(shape, dt1, dt2, scale, convert_policy, rounding_policy); \

85

}

86

87

#define PIXEL_WISE_MULTIPLICATION_FIXTURE_DATA_TEST_CASE(TEST_NAME, FIXTURE, MODE, SHAPES, DT1, DT2, SCALE, RP, VALIDATE) \

88

FIXTURE_DATA_TEST_CASE(TEST_NAME, NEPixelWiseMultiplication##FIXTURE, framework::DatasetMode::MODE, \

89

combine(combine(combine(combine(combine( \

90

datasets::SHAPES, \

91

framework::dataset::make("DataType1", DataType::DT1)), \

92

framework::dataset::make("DataType2", DataType::DT2)), \

93

framework::dataset::make("Scale", std::move(SCALE))), \

94

datasets::ConvertPolicies()), \

95

framework::dataset::make("RoundingPolicy", RoundingPolicy::RP))) \

96

{ \

97

VALIDATE \

98

}

Manuel Bottini

2019-02-22 17:54:22 +0000

[diff] [blame]

99

John Richardson

2017-09-18 16:10:48 +0100

[diff] [blame]

// *INDENT-ON*

// clang-format on

void validate_configuration(TensorShape shape, DataType dt1, DataType dt2, float scale, ConvertPolicy convert_policy, RoundingPolicy rounding_policy)

104

{

105

Tensor src1 = create_tensor<Tensor>(shape, dt1);

106

Tensor src2 = create_tensor<Tensor>(shape, dt2);

107

Tensor dst = create_tensor<Tensor>(shape, dt2);

108

109

ARM_COMPUTE_EXPECT(src1.info()->is_resizable(), framework::LogLevel::ERRORS);

110

ARM_COMPUTE_EXPECT(src2.info()->is_resizable(), framework::LogLevel::ERRORS);

111

ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);

112

113

// Create and configure function

114

NEPixelWiseMultiplication multiply;

115

multiply.configure(&src1, &src2, &dst, scale, convert_policy, rounding_policy);

116

117

// Validate valid region

118

const ValidRegion valid_region = shape_to_valid_region(shape);

119

validate(src1.info()->valid_region(), valid_region);

120

validate(src2.info()->valid_region(), valid_region);

121

validate(dst.info()->valid_region(), valid_region);

122

123

// Validate padding

124

const PaddingSize padding = PaddingCalculator(shape.x(), 16).required_padding();

125

validate(src1.info()->padding(), padding);

126

validate(src2.info()->padding(), padding);

127

validate(dst.info()->padding(), padding);

}

} // namespace

Pablo Tello

2019-12-10 11:28:53 +0000

[diff] [blame^]

131

using NEPixelWiseMultiplicationQASYMM8Fixture = PixelWiseMultiplicationValidationQuantizedFixture<Tensor, Accessor, NEPixelWiseMultiplication, uint8_t, uint8_t>;

132

using NEPixelWiseMultiplicationQASYMM8SignedFixture = PixelWiseMultiplicationValidationQuantizedFixture<Tensor, Accessor, NEPixelWiseMultiplication, int8_t, int8_t>;

133

using NEPixelWiseMultiplicationQSYMM16Fixture = PixelWiseMultiplicationValidationQuantizedFixture<Tensor, Accessor, NEPixelWiseMultiplication, int16_t, int16_t>;

John Richardson

2017-09-18 16:10:48 +0100

[diff] [blame]

134

template <typename T>

135

using NEPixelWiseMultiplicationToU8Fixture = PixelWiseMultiplicationValidationFixture<Tensor, Accessor, NEPixelWiseMultiplication, T, uint8_t>;

136

template <typename T>

137

using NEPixelWiseMultiplicationToS16Fixture = PixelWiseMultiplicationValidationFixture<Tensor, Accessor, NEPixelWiseMultiplication, T, int16_t>;

138

template <typename T>

139

using NEPixelWiseMultiplicationToF16Fixture = PixelWiseMultiplicationValidationFixture<Tensor, Accessor, NEPixelWiseMultiplication, T, half_float::half>;

140

template <typename T>

141

using NEPixelWiseMultiplicationToF32Fixture = PixelWiseMultiplicationValidationFixture<Tensor, Accessor, NEPixelWiseMultiplication, T, float>;

142

template <typename T>

Michalis Spyrou

861f0db

2018-02-26 16:47:58 +0000

[diff] [blame]

143

using NEPixelWiseMultiplicationBroadcastFixture = PixelWiseMultiplicationBroadcastValidationFixture<Tensor, Accessor, NEPixelWiseMultiplication, T, float>;

John Richardson

2017-09-18 16:10:48 +0100

[diff] [blame]

144

145

TEST_SUITE(NEON)

146

TEST_SUITE(PixelWiseMultiplication)

147

Ioan-Cristian Szabo

2017-11-28 18:29:43 +0000

[diff] [blame]

148

// *INDENT-OFF*

149

// clang-format off

Pablo Tello

2019-12-10 11:28:53 +0000

[diff] [blame^]

150

DATA_TEST_CASE(Validate, framework::DatasetMode::ALL, zip(zip(zip(zip(zip(

151

framework::dataset::make("Input1Info", { TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8), //1 Ok

152

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8), //2 Ok

153

TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::U8), //3 Window shrink

154

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8), //4 Invalid scale

155

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8), //5 Invalid data type combination

156

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), //6 Mismatching shapes

157

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), //7 Mismatching data type

158

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::QASYMM8), //8 Mismatching data type

159

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::QASYMM8_SIGNED), //9 Ok

160

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::QASYMM8_SIGNED), //10 Mismatching data type

161

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::QASYMM8), //11 Mismatching data type

162

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::QASYMM8), //12 Ok

163

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::QASYMM8_SIGNED), //13 Quantized cannot do WRAP

Ioan-Cristian Szabo

2017-11-28 18:29:43 +0000

[diff] [blame]

164

}),

165

framework::dataset::make("Input2Info",{ TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8),

166

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8),

167

TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::U8),

168

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8),

169

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::S16),

170

TensorInfo(TensorShape(48U, 11U, 2U), 1, DataType::F32),

Vidhya Sudhan Loganathan

0fc2545

2018-06-18 14:40:56 +0100

[diff] [blame]

171

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8),

Manuel Bottini

2019-02-22 17:54:22 +0000

[diff] [blame]

172

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8),

Pablo Tello

2019-12-10 11:28:53 +0000

[diff] [blame^]

173

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::QASYMM8_SIGNED),

174

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::QASYMM8),

175

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::QASYMM8_SIGNED),

176

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::QASYMM8),

177

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::QASYMM8_SIGNED),

Ioan-Cristian Szabo

2017-11-28 18:29:43 +0000

[diff] [blame]

178

})),

179

framework::dataset::make("OutputInfo",{ TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::S16),

180

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8),

181

TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::U8),

182

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8),

183

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8),

184

TensorInfo(TensorShape(48U, 11U, 2U), 1, DataType::F32),

Vidhya Sudhan Loganathan

0fc2545

2018-06-18 14:40:56 +0100

[diff] [blame]

185

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8),

Manuel Bottini

2019-02-22 17:54:22 +0000

[diff] [blame]

186

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8),

Pablo Tello

2019-12-10 11:28:53 +0000

[diff] [blame^]

187

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::QASYMM8_SIGNED),

188

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::QASYMM8_SIGNED),

189

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::QASYMM8_SIGNED),

190

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::QASYMM8),

191

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::QASYMM8_SIGNED),

Ioan-Cristian Szabo

2017-11-28 18:29:43 +0000

[diff] [blame]

192

})),

Pablo Tello

2019-12-10 11:28:53 +0000

[diff] [blame^]

193

framework::dataset::make("Scale",{ scale_unity,

scale_unity,

scale_unity,

-1.f,

scale_unity,

scale_unity,

scale_unity,

scale_unity,

scale_unity,

scale_unity,

scale_unity,

scale_unity,

scale_unity})),

framework::dataset::make("OverflowPolicy",{

ConvertPolicy::WRAP,

ConvertPolicy::WRAP,

ConvertPolicy::WRAP,

ConvertPolicy::WRAP,

ConvertPolicy::WRAP,

ConvertPolicy::WRAP,

ConvertPolicy::WRAP,

ConvertPolicy::WRAP,

ConvertPolicy::SATURATE,

216

ConvertPolicy::WRAP,

217

ConvertPolicy::WRAP,

218

ConvertPolicy::SATURATE,

ConvertPolicy::WRAP,

})),

framework::dataset::make("Expected", { true, true, false, false, false, false, false, false, true , false, false, true, false })),

223

input1_info, input2_info, output_info, scale, policy, expected)

Ioan-Cristian Szabo

2017-11-28 18:29:43 +0000

[diff] [blame]

224

{

Pablo Tello

2019-12-10 11:28:53 +0000

[diff] [blame^]

225

bool has_error = bool(NEPixelWiseMultiplication::validate(&input1_info.clone()->set_is_resizable(false), &input2_info.clone()->set_is_resizable(false), &output_info.clone()->set_is_resizable(false), scale, policy, RoundingPolicy::TO_ZERO));

Ioan-Cristian Szabo

2017-11-28 18:29:43 +0000

[diff] [blame]

226

ARM_COMPUTE_EXPECT(has_error == expected, framework::LogLevel::ERRORS);

}

// clang-format on

// *INDENT-ON*

Manuel Bottini

2019-06-26 15:17:09 +0100

[diff] [blame]

231

TEST_SUITE(Quantized)

Pablo Tello

2019-12-10 11:28:53 +0000

[diff] [blame^]

232

TEST_SUITE(QASYMM8_SIGNED)

233

TEST_SUITE(Scale255)

234

FIXTURE_DATA_TEST_CASE(RunSmall, NEPixelWiseMultiplicationQASYMM8SignedFixture, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(),

235

framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)),

236

framework::dataset::make("Scale", { scale_unity })),

237

PixelWiseMultiplicationPolicySTZDataset),

238

PixelWiseMultiplicationQASYMM8QuantDataset))

239

{

240

// Validate output

241

validate(Accessor(_target), _reference, tolerance_qasymm8);

242

}

243

TEST_SUITE_END() // Scale255

244

TEST_SUITE_END() // QASYMM8

245

Manuel Bottini

2019-06-26 15:17:09 +0100

[diff] [blame]

246

TEST_SUITE(QASYMM8)

Manuel Bottini

2019-02-22 17:54:22 +0000

[diff] [blame]

247

TEST_SUITE(Scale255)

Manuel Bottini

2019-06-26 15:17:09 +0100

[diff] [blame]

248

FIXTURE_DATA_TEST_CASE(RunSmall, NEPixelWiseMultiplicationQASYMM8Fixture, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(),

249

framework::dataset::make("DataType", DataType::QASYMM8)),

250

framework::dataset::make("Scale", { scale_255 })),

251

PixelWiseMultiplicationPolicySTNUDataset),

252

PixelWiseMultiplicationQASYMM8QuantDataset))

253

{

254

// Validate output

255

validate(Accessor(_target), _reference, tolerance_qasymm8);

256

}

257

FIXTURE_DATA_TEST_CASE(RunLarge, NEPixelWiseMultiplicationQASYMM8Fixture, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeShapes(),

258

framework::dataset::make("DataType", DataType::QASYMM8)),

259

framework::dataset::make("Scale", { scale_255 })),

260

PixelWiseMultiplicationPolicySTNUDataset),

261

PixelWiseMultiplicationQASYMM8QuantDataset))

262

{

263

// Validate output

264

validate(Accessor(_target), _reference, tolerance_qasymm8);

265

}

Manuel Bottini

2019-02-22 17:54:22 +0000

[diff] [blame]

266

TEST_SUITE_END() // Scale255

Manuel Bottini

2019-02-22 17:54:22 +0000

[diff] [blame]

267

TEST_SUITE(ScaleUnity)

Manuel Bottini

2019-06-26 15:17:09 +0100

[diff] [blame]

268

FIXTURE_DATA_TEST_CASE(RunSmall, NEPixelWiseMultiplicationQASYMM8Fixture, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(),

269

framework::dataset::make("DataType", DataType::QASYMM8)),

270

framework::dataset::make("Scale", { scale_unity })),

271

PixelWiseMultiplicationPolicySTZDataset),

272

PixelWiseMultiplicationQASYMM8QuantDataset))

273

{

274

// Validate output

275

validate(Accessor(_target), _reference, tolerance_qasymm8);

276

}

277

FIXTURE_DATA_TEST_CASE(RunLarge, NEPixelWiseMultiplicationQASYMM8Fixture, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeShapes(),

278

framework::dataset::make("DataType", DataType::QASYMM8)),

279

framework::dataset::make("Scale", { scale_unity })),

280

PixelWiseMultiplicationPolicySTZDataset),

281

PixelWiseMultiplicationQASYMM8QuantDataset))

282

{

283

// Validate output

284

validate(Accessor(_target), _reference, tolerance_qasymm8);

285

}

Manuel Bottini

2019-02-22 17:54:22 +0000

[diff] [blame]

286

TEST_SUITE_END() // ScaleUnity

Manuel Bottini

2019-02-22 17:54:22 +0000

[diff] [blame]

287

TEST_SUITE(ScaleOther)

Manuel Bottini

2019-06-26 15:17:09 +0100

[diff] [blame]

288

FIXTURE_DATA_TEST_CASE(RunSmall, NEPixelWiseMultiplicationQASYMM8Fixture, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(),

289

framework::dataset::make("DataType", DataType::QASYMM8)),

290

framework::dataset::make("Scale", { scale_other })),

291

PixelWiseMultiplicationPolicySTZDataset),

292

PixelWiseMultiplicationQASYMM8QuantDataset))

293

{

294

// Validate output

295

validate(Accessor(_target), _reference, tolerance_qasymm8);

296

}

297

FIXTURE_DATA_TEST_CASE(RunLarge, NEPixelWiseMultiplicationQASYMM8Fixture, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeShapes(),

298

framework::dataset::make("DataType", DataType::QASYMM8)),

299

framework::dataset::make("Scale", { scale_other })),

300

PixelWiseMultiplicationPolicySTZDataset),

301

PixelWiseMultiplicationQASYMM8QuantDataset))

302

{

303

// Validate output

304

validate(Accessor(_target), _reference, tolerance_qasymm8);

305

}

Manuel Bottini

2019-02-22 17:54:22 +0000

[diff] [blame]

306

TEST_SUITE_END() // ScaleOther

Manuel Bottini

2019-06-26 15:17:09 +0100

[diff] [blame]

307

TEST_SUITE_END() // QASYMM8

308

TEST_SUITE(QSYMM16)

309

TEST_SUITE(Scale255)

310

FIXTURE_DATA_TEST_CASE(RunSmall, NEPixelWiseMultiplicationQSYMM16Fixture, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(),

311

framework::dataset::make("DataType", DataType::QSYMM16)),

312

framework::dataset::make("Scale", { scale_255 })),

313

PixelWiseMultiplicationPolicySTNUDataset),

314

PixelWiseMultiplicationQSYMM16QuantDataset))

315

{

316

// Validate output

Michalis Spyrou

2019-07-05 15:20:09 +0100

[diff] [blame]

317

validate(Accessor(_target), _reference, tolerance_qsymm16);

Manuel Bottini

2019-06-26 15:17:09 +0100

[diff] [blame]

318

}

319

FIXTURE_DATA_TEST_CASE(RunLarge, NEPixelWiseMultiplicationQSYMM16Fixture, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeShapes(),

320

framework::dataset::make("DataType", DataType::QSYMM16)),

321

framework::dataset::make("Scale", { scale_255 })),

322

PixelWiseMultiplicationPolicySTNUDataset),

323

PixelWiseMultiplicationQSYMM16QuantDataset))

324

{

325

// Validate output

Michalis Spyrou

2019-07-05 15:20:09 +0100

[diff] [blame]

326

validate(Accessor(_target), _reference, tolerance_qsymm16);

Manuel Bottini

2019-06-26 15:17:09 +0100

[diff] [blame]

327

}

328

TEST_SUITE_END() // Scale255

329

TEST_SUITE(ScaleUnity)

330

FIXTURE_DATA_TEST_CASE(RunSmall, NEPixelWiseMultiplicationQSYMM16Fixture, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(),

331

framework::dataset::make("DataType", DataType::QSYMM16)),

332

framework::dataset::make("Scale", { scale_unity })),

333

PixelWiseMultiplicationPolicySTZDataset),

334

PixelWiseMultiplicationQSYMM16QuantDataset))

335

{

336

// Validate output

Michalis Spyrou

2019-07-05 15:20:09 +0100

[diff] [blame]

337

validate(Accessor(_target), _reference, tolerance_qsymm16);

Manuel Bottini

2019-06-26 15:17:09 +0100

[diff] [blame]

338

}

339

FIXTURE_DATA_TEST_CASE(RunLarge, NEPixelWiseMultiplicationQSYMM16Fixture, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeShapes(),

340

framework::dataset::make("DataType", DataType::QSYMM16)),

341

framework::dataset::make("Scale", { scale_unity })),

342

PixelWiseMultiplicationPolicySTZDataset),

343

PixelWiseMultiplicationQSYMM16QuantDataset))

344

{

345

// Validate output

Michalis Spyrou

2019-07-05 15:20:09 +0100

[diff] [blame]

346

validate(Accessor(_target), _reference, tolerance_qsymm16);

Manuel Bottini

2019-06-26 15:17:09 +0100

[diff] [blame]

347

}

348

TEST_SUITE_END() // ScaleUnity

349

TEST_SUITE(ScaleOther)

350

FIXTURE_DATA_TEST_CASE(RunSmall, NEPixelWiseMultiplicationQSYMM16Fixture, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(),

351

framework::dataset::make("DataType", DataType::QSYMM16)),

352

framework::dataset::make("Scale", { scale_other })),

353

PixelWiseMultiplicationPolicySTZDataset),

354

PixelWiseMultiplicationQSYMM16QuantDataset))

355

{

356

// Validate output

Michalis Spyrou

2019-07-05 15:20:09 +0100

[diff] [blame]

357

validate(Accessor(_target), _reference, tolerance_qsymm16);

Manuel Bottini

2019-06-26 15:17:09 +0100

[diff] [blame]

358

}

359

FIXTURE_DATA_TEST_CASE(RunLarge, NEPixelWiseMultiplicationQSYMM16Fixture, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeShapes(),

360

framework::dataset::make("DataType", DataType::QSYMM16)),

361

framework::dataset::make("Scale", { scale_other })),

362

PixelWiseMultiplicationPolicySTZDataset),

363

PixelWiseMultiplicationQSYMM16QuantDataset))

364

{

365

// Validate output

Michalis Spyrou

2019-07-05 15:20:09 +0100

[diff] [blame]

366

validate(Accessor(_target), _reference, tolerance_qsymm16);

Manuel Bottini

2019-06-26 15:17:09 +0100

[diff] [blame]

367

}

368

TEST_SUITE_END() // ScaleOther

369

TEST_SUITE_END() // QSYMM16

370

TEST_SUITE_END() // Quantized

Manuel Bottini

2019-02-22 17:54:22 +0000

[diff] [blame]

371

John Richardson

2017-09-18 16:10:48 +0100

[diff] [blame]

TEST_SUITE(U8toU8)

TEST_SUITE(Scale255)

PIXEL_WISE_MULTIPLICATION_DATA_TEST_CASE(U8, U8, scale_255, TO_NEAREST_UP)

376

PIXEL_WISE_MULTIPLICATION_FIXTURE_DATA_TEST_CASE(RunSmall, ToU8Fixture<uint8_t>, PRECOMMIT, SmallShapes(), U8, U8, scale_255, TO_NEAREST_UP, WRAP_VALIDATE(uint8_t, 1))

377

PIXEL_WISE_MULTIPLICATION_FIXTURE_DATA_TEST_CASE(RunLarge, ToU8Fixture<uint8_t>, NIGHTLY, LargeShapes(), U8, U8, scale_255, TO_NEAREST_UP, WRAP_VALIDATE(uint8_t, 1))

378

TEST_SUITE_END() // Scale255

379

380

TEST_SUITE(ScaleUnity)

381

PIXEL_WISE_MULTIPLICATION_DATA_TEST_CASE(U8, U8, scale_unity, TO_ZERO)

382

PIXEL_WISE_MULTIPLICATION_FIXTURE_DATA_TEST_CASE(RunSmall, ToU8Fixture<uint8_t>, PRECOMMIT, SmallShapes(), U8, U8, scale_unity, TO_ZERO, DEFAULT_VALIDATE)

383

PIXEL_WISE_MULTIPLICATION_FIXTURE_DATA_TEST_CASE(RunLarge, ToU8Fixture<uint8_t>, NIGHTLY, LargeShapes(), U8, U8, scale_unity, TO_ZERO, DEFAULT_VALIDATE)

384

TEST_SUITE_END() // ScaleUnity

385

386

TEST_SUITE(ScaleOther)

387

PIXEL_WISE_MULTIPLICATION_DATA_TEST_CASE(U8, U8, scale_other, TO_ZERO)

388

PIXEL_WISE_MULTIPLICATION_FIXTURE_DATA_TEST_CASE(RunSmall, ToU8Fixture<uint8_t>, PRECOMMIT, SmallShapes(), U8, U8, scale_other, TO_ZERO, DEFAULT_VALIDATE)

389

PIXEL_WISE_MULTIPLICATION_FIXTURE_DATA_TEST_CASE(RunLarge, ToU8Fixture<uint8_t>, NIGHTLY, LargeShapes(), U8, U8, scale_other, TO_ZERO, DEFAULT_VALIDATE)

390

TEST_SUITE_END() // ScaleOther

391

392

TEST_SUITE_END() // U8toU8

TEST_SUITE(U8toS16)

TEST_SUITE(Scale255)

PIXEL_WISE_MULTIPLICATION_DATA_TEST_CASE(U8, S16, scale_255, TO_NEAREST_UP)

398

PIXEL_WISE_MULTIPLICATION_FIXTURE_DATA_TEST_CASE(RunSmall, ToS16Fixture<uint8_t>, PRECOMMIT, SmallShapes(), U8, S16, scale_255, TO_NEAREST_UP, WRAP_VALIDATE(int16_t, 2))

399

PIXEL_WISE_MULTIPLICATION_FIXTURE_DATA_TEST_CASE(RunLarge, ToS16Fixture<uint8_t>, NIGHTLY, LargeShapes(), U8, S16, scale_255, TO_NEAREST_UP, WRAP_VALIDATE(int16_t, 2))

400

TEST_SUITE_END() // Scale255

401

402

TEST_SUITE(ScaleUnity)

403

PIXEL_WISE_MULTIPLICATION_DATA_TEST_CASE(U8, S16, scale_unity, TO_ZERO)

404

PIXEL_WISE_MULTIPLICATION_FIXTURE_DATA_TEST_CASE(RunSmall, ToS16Fixture<uint8_t>, PRECOMMIT, SmallShapes(), U8, S16, scale_unity, TO_ZERO, DEFAULT_VALIDATE)

405

PIXEL_WISE_MULTIPLICATION_FIXTURE_DATA_TEST_CASE(RunLarge, ToS16Fixture<uint8_t>, NIGHTLY, LargeShapes(), U8, S16, scale_unity, TO_ZERO, DEFAULT_VALIDATE)

406

TEST_SUITE_END() // ScaleUnity

407

408

TEST_SUITE(ScaleOther)

409

PIXEL_WISE_MULTIPLICATION_DATA_TEST_CASE(U8, S16, scale_other, TO_ZERO)

410

PIXEL_WISE_MULTIPLICATION_FIXTURE_DATA_TEST_CASE(RunSmall, ToS16Fixture<uint8_t>, PRECOMMIT, SmallShapes(), U8, S16, scale_other, TO_ZERO, DEFAULT_VALIDATE)

411

PIXEL_WISE_MULTIPLICATION_FIXTURE_DATA_TEST_CASE(RunLarge, ToS16Fixture<uint8_t>, NIGHTLY, LargeShapes(), U8, S16, scale_other, TO_ZERO, DEFAULT_VALIDATE)

412

TEST_SUITE_END() // ScaleOther

413

414

TEST_SUITE_END() // U8toS16

TEST_SUITE(S16toS16)

TEST_SUITE(Scale255)

PIXEL_WISE_MULTIPLICATION_DATA_TEST_CASE(S16, S16, scale_255, TO_NEAREST_UP)

420

PIXEL_WISE_MULTIPLICATION_FIXTURE_DATA_TEST_CASE(RunSmall, ToS16Fixture<int16_t>, PRECOMMIT, SmallShapes(), S16, S16, scale_255, TO_NEAREST_UP, WRAP_VALIDATE(int16_t, 2))

421

PIXEL_WISE_MULTIPLICATION_FIXTURE_DATA_TEST_CASE(RunLarge, ToS16Fixture<int16_t>, NIGHTLY, LargeShapes(), S16, S16, scale_255, TO_NEAREST_UP, WRAP_VALIDATE(int16_t, 2))

422

TEST_SUITE_END() // Scale255

423

424

TEST_SUITE(ScaleUnity)

425

PIXEL_WISE_MULTIPLICATION_DATA_TEST_CASE(S16, S16, scale_unity, TO_ZERO)

426

PIXEL_WISE_MULTIPLICATION_FIXTURE_DATA_TEST_CASE(RunSmall, ToS16Fixture<int16_t>, PRECOMMIT, SmallShapes(), S16, S16, scale_unity, TO_ZERO, DEFAULT_VALIDATE)

427

PIXEL_WISE_MULTIPLICATION_FIXTURE_DATA_TEST_CASE(RunLarge, ToS16Fixture<int16_t>, NIGHTLY, LargeShapes(), S16, S16, scale_unity, TO_ZERO, DEFAULT_VALIDATE)

428

TEST_SUITE_END() // ScaleUnity

429

430

TEST_SUITE(ScaleOther)

431

PIXEL_WISE_MULTIPLICATION_DATA_TEST_CASE(S16, S16, scale_other, TO_ZERO)

432

PIXEL_WISE_MULTIPLICATION_FIXTURE_DATA_TEST_CASE(RunSmall, ToS16Fixture<int16_t>, PRECOMMIT, SmallShapes(), S16, S16, scale_other, TO_ZERO, DEFAULT_VALIDATE)

433

PIXEL_WISE_MULTIPLICATION_FIXTURE_DATA_TEST_CASE(RunLarge, ToS16Fixture<int16_t>, NIGHTLY, LargeShapes(), S16, S16, scale_other, TO_ZERO, DEFAULT_VALIDATE)

434

TEST_SUITE_END() // ScaleOther

435

436

TEST_SUITE_END() // S16toS16

437

Ioan-Cristian Szabo

5edbd1c

2017-11-13 13:34:08 +0000

[diff] [blame]

438

#ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC

John Richardson

2017-09-18 16:10:48 +0100

[diff] [blame]

439

TEST_SUITE(F16toF16)

440

441

TEST_SUITE(Scale255)

John Richardson

9c450cc

2017-11-22 12:00:41 +0000

[diff] [blame]

442

PIXEL_WISE_MULTIPLICATION_FIXTURE_DATA_TEST_CASE(RunSmall, ToF16Fixture<half_float::half>, PRECOMMIT, SmallShapes(), F16, F16, scale_255, TO_NEAREST_UP, VALIDATE(float, 1.f))

John Richardson

2017-09-18 16:10:48 +0100

[diff] [blame]

443

TEST_SUITE_END() // Scale255

444

445

TEST_SUITE_END() // F16toF16

Ioan-Cristian Szabo

5edbd1c

2017-11-13 13:34:08 +0000

[diff] [blame]

446

#endif /* __ARM_FEATURE_FP16_VECTOR_ARITHMETIC */

John Richardson

2017-09-18 16:10:48 +0100

[diff] [blame]

TEST_SUITE(F32toF32)

TEST_SUITE(Scale255)

PIXEL_WISE_MULTIPLICATION_DATA_TEST_CASE(F32, F32, scale_255, TO_NEAREST_UP)

John Richardson

9c450cc

2017-11-22 12:00:41 +0000

[diff] [blame]

452

PIXEL_WISE_MULTIPLICATION_FIXTURE_DATA_TEST_CASE(RunSmall, ToF32Fixture<float>, PRECOMMIT, SmallShapes(), F32, F32, scale_255, TO_NEAREST_UP, VALIDATE(float, 1.f))

453

PIXEL_WISE_MULTIPLICATION_FIXTURE_DATA_TEST_CASE(RunLarge, ToF32Fixture<float>, NIGHTLY, LargeShapes(), F32, F32, scale_255, TO_NEAREST_UP, VALIDATE(float, 1.f))

John Richardson

2017-09-18 16:10:48 +0100

[diff] [blame]

454

TEST_SUITE_END() // Scale255

455

456

TEST_SUITE(ScaleUnity)

457

PIXEL_WISE_MULTIPLICATION_DATA_TEST_CASE(F32, F32, scale_unity, TO_ZERO)

458

PIXEL_WISE_MULTIPLICATION_FIXTURE_DATA_TEST_CASE(RunSmall, ToF32Fixture<float>, PRECOMMIT, SmallShapes(), F32, F32, scale_unity, TO_ZERO, DEFAULT_VALIDATE)

459

PIXEL_WISE_MULTIPLICATION_FIXTURE_DATA_TEST_CASE(RunLarge, ToF32Fixture<float>, NIGHTLY, LargeShapes(), F32, F32, scale_unity, TO_ZERO, DEFAULT_VALIDATE)

460

TEST_SUITE_END() // ScaleUnity

461

462

TEST_SUITE(ScaleOther)

463

PIXEL_WISE_MULTIPLICATION_DATA_TEST_CASE(F32, F32, scale_other, TO_ZERO)

464

PIXEL_WISE_MULTIPLICATION_FIXTURE_DATA_TEST_CASE(RunSmall, ToF32Fixture<float>, PRECOMMIT, SmallShapes(), F32, F32, scale_other, TO_ZERO, DEFAULT_VALIDATE)

465

PIXEL_WISE_MULTIPLICATION_FIXTURE_DATA_TEST_CASE(RunLarge, ToF32Fixture<float>, NIGHTLY, LargeShapes(), F32, F32, scale_other, TO_ZERO, DEFAULT_VALIDATE)

466

TEST_SUITE_END() // ScaleOther

467

468

TEST_SUITE_END() // F32toF32

469

Michalis Spyrou

861f0db

2018-02-26 16:47:58 +0000

[diff] [blame]

470

TEST_SUITE(Broadcast)

471

PIXEL_WISE_MULTIPLICATION_FIXTURE_DATA_TEST_CASE(RunSmall, BroadcastFixture<float>, PRECOMMIT, SmallShapesBroadcast(), F32, F32, scale_255, TO_NEAREST_UP, VALIDATE(float, 1.f))

472

TEST_SUITE_END() // Broadcast

473

John Richardson