From 6997fc951e48a1bf8f7591f3b2c4c8d721331b96 Mon Sep 17 00:00:00 2001 From: Michele Di Giorgio Date: Tue, 18 Jun 2019 10:23:22 +0100 Subject: COMPMID-2412: Add QSYMM16 support for ElementwiseAddition for CL Arithmetic addition uses the same code as other element-wise operations. Hence, adding QSYMM16 support for addition automatically adds the same support for: - arithmetic subtraction - element-wise min - element-wise max - squared difference Change-Id: If986102844f62e29dd23c03f9245910db43f9043 Signed-off-by: Michele Di Giorgio Reviewed-on: https://review.mlplatform.org/c/1384 Tested-by: Arm Jenkins Comments-Addressed: Arm Jenkins Reviewed-by: Manuel Bottini Reviewed-by: Giuseppe Rossini Reviewed-by: Georgios Pinitas --- tests/validation/CL/ArithmeticAddition.cpp | 100 ++++++++++++++------ tests/validation/CL/ArithmeticSubtraction.cpp | 104 ++++++++++++++------- tests/validation/CL/ElementwiseMax.cpp | 85 ++++++++++++----- tests/validation/CL/ElementwiseMin.cpp | 85 ++++++++++++----- tests/validation/CL/ElementwiseSquaredDiff.cpp | 88 ++++++++++++----- .../validation/reference/ElementwiseOperations.cpp | 35 ++++++- 6 files changed, 357 insertions(+), 140 deletions(-) (limited to 'tests') diff --git a/tests/validation/CL/ArithmeticAddition.cpp b/tests/validation/CL/ArithmeticAddition.cpp index bed04af9e5..e9b4b16b0c 100644 --- a/tests/validation/CL/ArithmeticAddition.cpp +++ b/tests/validation/CL/ArithmeticAddition.cpp @@ -50,6 +50,9 @@ const auto ArithmeticAdditionU8Dataset = combine(combine(framework::dataset::mak const auto ArithmeticAdditionQASYMM8Dataset = combine(combine(framework::dataset::make("DataType", DataType::QASYMM8), framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("DataType", DataType::QASYMM8)); +const auto ArithmeticAdditionQSYMM16Dataset = combine(combine(framework::dataset::make("DataType", DataType::QSYMM16), framework::dataset::make("DataType", DataType::QSYMM16)), + framework::dataset::make("DataType", + DataType::QSYMM16)); const auto ArithmeticAdditionS16Dataset = combine(combine(framework::dataset::make("DataType", { DataType::U8, DataType::S16 }), framework::dataset::make("DataType", DataType::S16)), framework::dataset::make("DataType", DataType::S16)); const auto ArithmeticAdditionFP16Dataset = combine(combine(framework::dataset::make("DataType", DataType::F16), framework::dataset::make("DataType", DataType::F16)), @@ -93,6 +96,7 @@ DATA_TEST_CASE(Validate, framework::DatasetMode::ALL, zip(zip(zip( template using CLArithmeticAdditionFixture = ArithmeticAdditionValidationFixture; +TEST_SUITE(Integer) TEST_SUITE(U8) DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), shape, policy) @@ -123,7 +127,48 @@ FIXTURE_DATA_TEST_CASE(RunSmall, CLArithmeticAdditionFixture, framework // Validate output validate(CLAccessor(_target), _reference); } -TEST_SUITE_END() +TEST_SUITE_END() // U8 + +TEST_SUITE(S16) +DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType", { DataType::U8, DataType::S16 })), + framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), + shape, data_type, policy) +{ + // Create tensors + CLTensor ref_src1 = create_tensor(shape, data_type); + CLTensor ref_src2 = create_tensor(shape, DataType::S16); + CLTensor dst = create_tensor(shape, DataType::S16); + + // Create and Configure function + CLArithmeticAddition add; + add.configure(&ref_src1, &ref_src2, &dst, policy); + + // Validate valid region + const ValidRegion valid_region = shape_to_valid_region(shape); + validate(dst.info()->valid_region(), valid_region); + + // Validate padding + const PaddingSize padding = PaddingCalculator(shape.x(), num_elems_processed_per_iteration).required_padding(); + validate(ref_src1.info()->padding(), padding); + validate(ref_src2.info()->padding(), padding); + validate(dst.info()->padding(), padding); +} + +FIXTURE_DATA_TEST_CASE(RunSmall, CLArithmeticAdditionFixture, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), ArithmeticAdditionS16Dataset), + framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP }))) +{ + // Validate output + validate(CLAccessor(_target), _reference); +} + +FIXTURE_DATA_TEST_CASE(RunLarge, CLArithmeticAdditionFixture, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeShapes(), ArithmeticAdditionS16Dataset), + framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP }))) +{ + // Validate output + validate(CLAccessor(_target), _reference); +} +TEST_SUITE_END() // S16 +TEST_SUITE_END() // Integer template using CLArithmeticAdditionQuantizedFixture = ArithmeticAdditionValidationQuantizedFixture; @@ -156,27 +201,22 @@ DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(datasets::Sma FIXTURE_DATA_TEST_CASE(RunSmall, CLArithmeticAdditionQuantizedFixture, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(datasets::SmallShapes(), ArithmeticAdditionQASYMM8Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })), - framework::dataset::make("QuantizationInfo", { QuantizationInfo(5.f / 255.f, 20) })), - framework::dataset::make("QuantizationInfo", { QuantizationInfo(2.f / 255.f, 10) })), - framework::dataset::make("QuantizationInfo", { QuantizationInfo(1.f / 255.f, 5) })) - - ) + framework::dataset::make("Src0QInfo", { QuantizationInfo(5.f / 255.f, 20) })), + framework::dataset::make("Src1QInfo", { QuantizationInfo(2.f / 255.f, 10) })), + framework::dataset::make("OutQInfo", { QuantizationInfo(1.f / 255.f, 5) }))) { // Validate output validate(CLAccessor(_target), _reference); } -TEST_SUITE_END() -TEST_SUITE_END() - -TEST_SUITE(S16) -DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType", { DataType::U8, DataType::S16 })), - framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), - shape, data_type, policy) +TEST_SUITE_END() // QASYMM8 +TEST_SUITE(QSYMM16) +DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })), + shape, policy) { // Create tensors - CLTensor ref_src1 = create_tensor(shape, data_type); - CLTensor ref_src2 = create_tensor(shape, DataType::S16); - CLTensor dst = create_tensor(shape, DataType::S16); + CLTensor ref_src1 = create_tensor(shape, DataType::QSYMM16); + CLTensor ref_src2 = create_tensor(shape, DataType::QSYMM16); + CLTensor dst = create_tensor(shape, DataType::QSYMM16); // Create and Configure function CLArithmeticAddition add; @@ -193,20 +233,18 @@ DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(datas validate(dst.info()->padding(), padding); } -FIXTURE_DATA_TEST_CASE(RunSmall, CLArithmeticAdditionFixture, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), ArithmeticAdditionS16Dataset), - framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP }))) -{ - // Validate output - validate(CLAccessor(_target), _reference); -} - -FIXTURE_DATA_TEST_CASE(RunLarge, CLArithmeticAdditionFixture, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeShapes(), ArithmeticAdditionS16Dataset), - framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP }))) +FIXTURE_DATA_TEST_CASE(RunSmall, CLArithmeticAdditionQuantizedFixture, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(datasets::SmallShapes(), + ArithmeticAdditionQSYMM16Dataset), + framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })), + framework::dataset::make("Src0QInfo", { QuantizationInfo(1.f / 32768.f, 0), QuantizationInfo(5.f / 32768.f, 0) })), + framework::dataset::make("Src1QInfo", { QuantizationInfo(2.f / 32768.f, 0), QuantizationInfo(5.f / 32768.f, 0) })), + framework::dataset::make("OutQInfo", { QuantizationInfo(5.f / 32768.f, 0) }))) { // Validate output validate(CLAccessor(_target), _reference); } -TEST_SUITE_END() +TEST_SUITE_END() // QSYMM16 +TEST_SUITE_END() // Quantized TEST_SUITE(Float) TEST_SUITE(FP16) @@ -216,7 +254,7 @@ FIXTURE_DATA_TEST_CASE(RunSmall, CLArithmeticAdditionFixture, framework::D // Validate output validate(CLAccessor(_target), _reference); } -TEST_SUITE_END() +TEST_SUITE_END() // FP16 TEST_SUITE(FP32) DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), @@ -274,11 +312,11 @@ FIXTURE_DATA_TEST_CASE(RunLargeBroadcast, CLArithmeticAdditionBroadcastFixture using CLArithmeticSubtractionFixture = ArithmeticSubtractionValidationFixture; +TEST_SUITE(Integer) TEST_SUITE(U8) DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), shape, policy) @@ -124,7 +128,48 @@ FIXTURE_DATA_TEST_CASE(RunSmall, CLArithmeticSubtractionFixture, framew // Validate output validate(CLAccessor(_target), _reference); } -TEST_SUITE_END() +TEST_SUITE_END() // U8 + +TEST_SUITE(S16) +DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType", { DataType::U8, DataType::S16 })), + framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), + shape, data_type, policy) +{ + // Create tensors + CLTensor ref_src1 = create_tensor(shape, data_type); + CLTensor ref_src2 = create_tensor(shape, DataType::S16); + CLTensor dst = create_tensor(shape, DataType::S16); + + // Create and Configure function + CLArithmeticSubtraction add; + add.configure(&ref_src1, &ref_src2, &dst, policy); + + // Validate valid region + const ValidRegion valid_region = shape_to_valid_region(shape); + validate(dst.info()->valid_region(), valid_region); + + // Validate padding + const PaddingSize padding = PaddingCalculator(shape.x(), num_elems_processed_per_iteration).required_padding(); + validate(ref_src1.info()->padding(), padding); + validate(ref_src2.info()->padding(), padding); + validate(dst.info()->padding(), padding); +} + +FIXTURE_DATA_TEST_CASE(RunSmall, CLArithmeticSubtractionFixture, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), ArithmeticSubtractionS16Dataset), + framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP }))) +{ + // Validate output + validate(CLAccessor(_target), _reference); +} + +FIXTURE_DATA_TEST_CASE(RunLarge, CLArithmeticSubtractionFixture, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeShapes(), ArithmeticSubtractionS16Dataset), + framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP }))) +{ + // Validate output + validate(CLAccessor(_target), _reference); +} +TEST_SUITE_END() // S16 +TEST_SUITE_END() // Integer template using CLArithmeticSubtractionQuantizedFixture = ArithmeticSubtractionValidationQuantizedFixture; @@ -157,31 +202,26 @@ DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(datasets::Sma FIXTURE_DATA_TEST_CASE(RunSmall, CLArithmeticSubtractionQuantizedFixture, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(datasets::SmallShapes(), ArithmeticSubtractionQASYMM8Dataset), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })), - framework::dataset::make("QuantizationInfo", { QuantizationInfo(5.f / 255.f, 20) })), - framework::dataset::make("QuantizationInfo", { QuantizationInfo(2.f / 255.f, 10) })), - framework::dataset::make("QuantizationInfo", { QuantizationInfo(1.f / 255.f, 5) })) - - ) + framework::dataset::make("Src0QInfo", { QuantizationInfo(5.f / 255.f, 20) })), + framework::dataset::make("Src1QInfo", { QuantizationInfo(2.f / 255.f, 10) })), + framework::dataset::make("OutQInfo", { QuantizationInfo(1.f / 255.f, 5) }))) { // Validate output validate(CLAccessor(_target), _reference); } -TEST_SUITE_END() -TEST_SUITE_END() - -TEST_SUITE(S16) -DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType", { DataType::U8, DataType::S16 })), - framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), - shape, data_type, policy) +TEST_SUITE_END() // QASYMM8 +TEST_SUITE(QSYMM16) +DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })), + shape, policy) { // Create tensors - CLTensor ref_src1 = create_tensor(shape, data_type); - CLTensor ref_src2 = create_tensor(shape, DataType::S16); - CLTensor dst = create_tensor(shape, DataType::S16); + CLTensor ref_src1 = create_tensor(shape, DataType::QSYMM16); + CLTensor ref_src2 = create_tensor(shape, DataType::QSYMM16); + CLTensor dst = create_tensor(shape, DataType::QSYMM16); // Create and Configure function - CLArithmeticSubtraction add; - add.configure(&ref_src1, &ref_src2, &dst, policy); + CLArithmeticSubtraction sub; + sub.configure(&ref_src1, &ref_src2, &dst, policy); // Validate valid region const ValidRegion valid_region = shape_to_valid_region(shape); @@ -194,20 +234,18 @@ DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(datas validate(dst.info()->padding(), padding); } -FIXTURE_DATA_TEST_CASE(RunSmall, CLArithmeticSubtractionFixture, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), ArithmeticSubtractionS16Dataset), - framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP }))) -{ - // Validate output - validate(CLAccessor(_target), _reference); -} - -FIXTURE_DATA_TEST_CASE(RunLarge, CLArithmeticSubtractionFixture, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeShapes(), ArithmeticSubtractionS16Dataset), - framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP }))) +FIXTURE_DATA_TEST_CASE(RunSmall, CLArithmeticSubtractionQuantizedFixture, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(combine(datasets::SmallShapes(), + ArithmeticSubtractionQSYMM16Dataset), + framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })), + framework::dataset::make("Src0QInfo", { QuantizationInfo(1.f / 32768.f, 0), QuantizationInfo(5.f / 32768.f, 0) })), + framework::dataset::make("Src1QInfo", { QuantizationInfo(2.f / 32768.f, 0), QuantizationInfo(5.f / 32768.f, 0) })), + framework::dataset::make("OutQInfo", { QuantizationInfo(5.f / 32768.f, 0) }))) { // Validate output validate(CLAccessor(_target), _reference); } -TEST_SUITE_END() +TEST_SUITE_END() // QSYMM16 +TEST_SUITE_END() // Quantized TEST_SUITE(Float) TEST_SUITE(FP16) @@ -217,7 +255,7 @@ FIXTURE_DATA_TEST_CASE(RunSmall, CLArithmeticSubtractionFixture, framework // Validate output validate(CLAccessor(_target), _reference); } -TEST_SUITE_END() +TEST_SUITE_END() // FP16 TEST_SUITE(FP32) DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), @@ -275,11 +313,11 @@ FIXTURE_DATA_TEST_CASE(RunLargeBroadcast, CLArithmeticSubtractionBroadcastFixtur // Validate output validate(CLAccessor(_target), _reference); } -TEST_SUITE_END() -TEST_SUITE_END() +TEST_SUITE_END() // FP32 +TEST_SUITE_END() // Float -TEST_SUITE_END() -TEST_SUITE_END() +TEST_SUITE_END() // ArithmeticSubtraction +TEST_SUITE_END() // CL } // namespace validation } // namespace test } // namespace arm_compute diff --git a/tests/validation/CL/ElementwiseMax.cpp b/tests/validation/CL/ElementwiseMax.cpp index 773a91905e..255acbe645 100644 --- a/tests/validation/CL/ElementwiseMax.cpp +++ b/tests/validation/CL/ElementwiseMax.cpp @@ -53,6 +53,9 @@ const auto ElementwiseMaxU8Dataset = combine(combine(framework::dataset::make("D const auto ElementwiseMaxQASYMM8Dataset = combine(combine(framework::dataset::make("DataType", DataType::QASYMM8), framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("DataType", DataType::QASYMM8)); +const auto ElementwiseMaxQSYMM16Dataset = combine(combine(framework::dataset::make("DataType", DataType::QSYMM16), framework::dataset::make("DataType", DataType::QSYMM16)), + framework::dataset::make("DataType", + DataType::QSYMM16)); const auto ElementwiseMaxS16Dataset = combine(combine(framework::dataset::make("DataType", { DataType::U8, DataType::S16 }), framework::dataset::make("DataType", DataType::S16)), framework::dataset::make("DataType", DataType::S16)); const auto ElementwiseMaxFP16Dataset = combine(combine(framework::dataset::make("DataType", DataType::F16), framework::dataset::make("DataType", DataType::F16)), @@ -96,6 +99,7 @@ DATA_TEST_CASE(Validate, framework::DatasetMode::ALL, zip(zip(zip( template using CLElementwiseMaxFixture = ElementwiseMaxValidationFixture; +TEST_SUITE(Integer) TEST_SUITE(U8) DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, datasets::SmallShapes(), shape) @@ -106,8 +110,8 @@ DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, datasets::SmallShapes CLTensor dst = create_tensor(shape, DataType::U8); // Create and Configure function - CLElementwiseMax add; - add.configure(&ref_src1, &ref_src2, &dst); + CLElementwiseMax max; + max.configure(&ref_src1, &ref_src2, &dst); // Validate valid region const ValidRegion valid_region = shape_to_valid_region(shape); @@ -127,6 +131,38 @@ FIXTURE_DATA_TEST_CASE(RunSmall, CLElementwiseMaxFixture, framework::Da } TEST_SUITE_END() +TEST_SUITE(S16) +DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), framework::dataset::make("DataType", { DataType::U8, DataType::S16 })), + shape, data_type) +{ + // Create tensors + CLTensor ref_src1 = create_tensor(shape, data_type); + CLTensor ref_src2 = create_tensor(shape, DataType::S16); + CLTensor dst = create_tensor(shape, DataType::S16); + + // Create and Configure function + CLElementwiseMax max; + max.configure(&ref_src1, &ref_src2, &dst); + + // Validate valid region + const ValidRegion valid_region = shape_to_valid_region(shape); + validate(dst.info()->valid_region(), valid_region); + + // Validate padding + const PaddingSize padding = PaddingCalculator(shape.x(), num_elems_processed_per_iteration).required_padding(); + validate(ref_src1.info()->padding(), padding); + validate(ref_src2.info()->padding(), padding); + validate(dst.info()->padding(), padding); +} + +FIXTURE_DATA_TEST_CASE(RunSmall, CLElementwiseMaxFixture, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), ElementwiseMaxS16Dataset)) +{ + // Validate output + validate(CLAccessor(_target), _reference); +} +TEST_SUITE_END() +TEST_SUITE_END() + template using CLElementwiseMaxQuantizedFixture = ElementwiseMaxValidationQuantizedFixture; @@ -141,8 +177,8 @@ DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, datasets::SmallShapes CLTensor dst = create_tensor(shape, DataType::QASYMM8); // Create and Configure function - CLElementwiseMax add; - add.configure(&ref_src1, &ref_src2, &dst); + CLElementwiseMax max; + max.configure(&ref_src1, &ref_src2, &dst); // Validate valid region const ValidRegion valid_region = shape_to_valid_region(shape); @@ -157,30 +193,26 @@ DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, datasets::SmallShapes FIXTURE_DATA_TEST_CASE(RunSmall, CLElementwiseMaxQuantizedFixture, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(), ElementwiseMaxQASYMM8Dataset), - framework::dataset::make("QuantizationInfo", { QuantizationInfo(5.f / 255.f, 20) })), - framework::dataset::make("QuantizationInfo", { QuantizationInfo(2.f / 255.f, 10) })), - framework::dataset::make("QuantizationInfo", { QuantizationInfo(1.f / 255.f, 5) })) - - ) + framework::dataset::make("Src0QInfo", { QuantizationInfo(5.f / 255.f, 20) })), + framework::dataset::make("Src1QInfo", { QuantizationInfo(2.f / 255.f, 10) })), + framework::dataset::make("OutQInfo", { QuantizationInfo(1.f / 255.f, 5) }))) { // Validate output validate(CLAccessor(_target), _reference, tolerance_fp32, 0.01); } TEST_SUITE_END() -TEST_SUITE_END() - -TEST_SUITE(S16) -DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), framework::dataset::make("DataType", { DataType::U8, DataType::S16 })), - shape, data_type) +TEST_SUITE(QSYMM16) +DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, datasets::SmallShapes(), + shape) { // Create tensors - CLTensor ref_src1 = create_tensor(shape, data_type); - CLTensor ref_src2 = create_tensor(shape, DataType::S16); - CLTensor dst = create_tensor(shape, DataType::S16); + CLTensor ref_src1 = create_tensor(shape, DataType::QSYMM16); + CLTensor ref_src2 = create_tensor(shape, DataType::QSYMM16); + CLTensor dst = create_tensor(shape, DataType::QSYMM16); // Create and Configure function - CLElementwiseMax add; - add.configure(&ref_src1, &ref_src2, &dst); + CLElementwiseMax max; + max.configure(&ref_src1, &ref_src2, &dst); // Validate valid region const ValidRegion valid_region = shape_to_valid_region(shape); @@ -193,12 +225,17 @@ DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(datasets::Sma validate(dst.info()->padding(), padding); } -FIXTURE_DATA_TEST_CASE(RunSmall, CLElementwiseMaxFixture, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), ElementwiseMaxS16Dataset)) +FIXTURE_DATA_TEST_CASE(RunSmall, CLElementwiseMaxQuantizedFixture, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(), + ElementwiseMaxQSYMM16Dataset), + framework::dataset::make("Src0QInfo", { QuantizationInfo(1.f / 32768.f, 0), QuantizationInfo(5.f / 32768.f, 0) })), + framework::dataset::make("Src1QInfo", { QuantizationInfo(2.f / 32768.f, 0), QuantizationInfo(5.f / 32768.f, 0) })), + framework::dataset::make("OutQInfo", { QuantizationInfo(5.f / 32768.f, 0) }))) { // Validate output validate(CLAccessor(_target), _reference); } TEST_SUITE_END() +TEST_SUITE_END() TEST_SUITE(Float) TEST_SUITE(FP16) @@ -219,8 +256,8 @@ DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, datasets::SmallShapes CLTensor dst = create_tensor(shape, DataType::F32); // Create and Configure function - CLElementwiseMax add; - add.configure(&ref_src1, &ref_src2, &dst); + CLElementwiseMax max; + max.configure(&ref_src1, &ref_src2, &dst); // Validate valid region const ValidRegion valid_region = shape_to_valid_region(shape); @@ -251,8 +288,8 @@ FIXTURE_DATA_TEST_CASE(RunSmallBroadcast, CLElementwiseMaxBroadcastFixture using CLElementwiseMinFixture = ElementwiseMinValidationFixture; +TEST_SUITE(Integer) TEST_SUITE(U8) DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, datasets::SmallShapes(), shape) @@ -106,8 +110,8 @@ DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, datasets::SmallShapes CLTensor dst = create_tensor(shape, DataType::U8); // Create and Configure function - CLElementwiseMin add; - add.configure(&ref_src1, &ref_src2, &dst); + CLElementwiseMin min; + min.configure(&ref_src1, &ref_src2, &dst); // Validate valid region const ValidRegion valid_region = shape_to_valid_region(shape); @@ -127,6 +131,38 @@ FIXTURE_DATA_TEST_CASE(RunSmall, CLElementwiseMinFixture, framework::Da } TEST_SUITE_END() +TEST_SUITE(S16) +DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), framework::dataset::make("DataType", { DataType::U8, DataType::S16 })), + shape, data_type) +{ + // Create tensors + CLTensor ref_src1 = create_tensor(shape, data_type); + CLTensor ref_src2 = create_tensor(shape, DataType::S16); + CLTensor dst = create_tensor(shape, DataType::S16); + + // Create and Configure function + CLElementwiseMin min; + min.configure(&ref_src1, &ref_src2, &dst); + + // Validate valid region + const ValidRegion valid_region = shape_to_valid_region(shape); + validate(dst.info()->valid_region(), valid_region); + + // Validate padding + const PaddingSize padding = PaddingCalculator(shape.x(), num_elems_processed_per_iteration).required_padding(); + validate(ref_src1.info()->padding(), padding); + validate(ref_src2.info()->padding(), padding); + validate(dst.info()->padding(), padding); +} + +FIXTURE_DATA_TEST_CASE(RunSmall, CLElementwiseMinFixture, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), ElementwiseMinS16Dataset)) +{ + // Validate output + validate(CLAccessor(_target), _reference); +} +TEST_SUITE_END() +TEST_SUITE_END() + template using CLElementwiseMinQuantizedFixture = ElementwiseMinValidationQuantizedFixture; @@ -141,8 +177,8 @@ DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, datasets::SmallShapes CLTensor dst = create_tensor(shape, DataType::QASYMM8); // Create and Configure function - CLElementwiseMin add; - add.configure(&ref_src1, &ref_src2, &dst); + CLElementwiseMin min; + min.configure(&ref_src1, &ref_src2, &dst); // Validate valid region const ValidRegion valid_region = shape_to_valid_region(shape); @@ -157,30 +193,26 @@ DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, datasets::SmallShapes FIXTURE_DATA_TEST_CASE(RunSmall, CLElementwiseMinQuantizedFixture, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(), ElementwiseMinQASYMM8Dataset), - framework::dataset::make("QuantizationInfo", { QuantizationInfo(5.f / 255.f, 20) })), - framework::dataset::make("QuantizationInfo", { QuantizationInfo(2.f / 255.f, 10) })), - framework::dataset::make("QuantizationInfo", { QuantizationInfo(1.f / 255.f, 5) })) - - ) + framework::dataset::make("Src0QInfo", { QuantizationInfo(5.f / 255.f, 20) })), + framework::dataset::make("Src1QInfo", { QuantizationInfo(2.f / 255.f, 10) })), + framework::dataset::make("OutQInfo", { QuantizationInfo(1.f / 255.f, 5) }))) { // Validate output validate(CLAccessor(_target), _reference, tolerance_fp32, 0.01); } TEST_SUITE_END() -TEST_SUITE_END() - -TEST_SUITE(S16) -DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), framework::dataset::make("DataType", { DataType::U8, DataType::S16 })), - shape, data_type) +TEST_SUITE(QSYMM16) +DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, datasets::SmallShapes(), + shape) { // Create tensors - CLTensor ref_src1 = create_tensor(shape, data_type); - CLTensor ref_src2 = create_tensor(shape, DataType::S16); - CLTensor dst = create_tensor(shape, DataType::S16); + CLTensor ref_src1 = create_tensor(shape, DataType::QSYMM16); + CLTensor ref_src2 = create_tensor(shape, DataType::QSYMM16); + CLTensor dst = create_tensor(shape, DataType::QSYMM16); // Create and Configure function - CLElementwiseMin add; - add.configure(&ref_src1, &ref_src2, &dst); + CLElementwiseMin min; + min.configure(&ref_src1, &ref_src2, &dst); // Validate valid region const ValidRegion valid_region = shape_to_valid_region(shape); @@ -193,12 +225,17 @@ DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(datasets::Sma validate(dst.info()->padding(), padding); } -FIXTURE_DATA_TEST_CASE(RunSmall, CLElementwiseMinFixture, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), ElementwiseMinS16Dataset)) +FIXTURE_DATA_TEST_CASE(RunSmall, CLElementwiseMinQuantizedFixture, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(), + ElementwiseMinQSYMM16Dataset), + framework::dataset::make("SrcQInfo0", { QuantizationInfo(1.f / 32768.f, 0), QuantizationInfo(5.f / 32768.f, 0) })), + framework::dataset::make("SrcQInfo1", { QuantizationInfo(2.f / 32768.f, 0), QuantizationInfo(5.f / 32768.f, 0) })), + framework::dataset::make("OutQInfo", { QuantizationInfo(5.f / 32768.f, 0) }))) { // Validate output validate(CLAccessor(_target), _reference); } TEST_SUITE_END() +TEST_SUITE_END() TEST_SUITE(Float) TEST_SUITE(FP16) @@ -219,8 +256,8 @@ DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, datasets::SmallShapes CLTensor dst = create_tensor(shape, DataType::F32); // Create and Configure function - CLElementwiseMin add; - add.configure(&ref_src1, &ref_src2, &dst); + CLElementwiseMin min; + min.configure(&ref_src1, &ref_src2, &dst); // Validate valid region const ValidRegion valid_region = shape_to_valid_region(shape); @@ -250,8 +287,8 @@ FIXTURE_DATA_TEST_CASE(RunSmallBroadcast, CLElementwiseMinBroadcastFixture tolerance_fp32(0.000001f); RelativeTolerance tolerance_fp16(0.001f); +AbsoluteTolerance tolerance_qsymm16(1); constexpr unsigned int num_elems_processed_per_iteration = 16; /** Input data sets **/ @@ -54,6 +55,9 @@ const auto ElementwiseSquaredDiffU8Dataset = combine(combine(framework::dataset: const auto ElementwiseSquaredDiffQASYMM8Dataset = combine(combine(framework::dataset::make("DataType", DataType::QASYMM8), framework::dataset::make("DataType", DataType::QASYMM8)), framework::dataset::make("DataType", DataType::QASYMM8)); +const auto ElementwiseSquaredDiffQSYMM16Dataset = combine(combine(framework::dataset::make("DataType", DataType::QSYMM16), framework::dataset::make("DataType", DataType::QSYMM16)), + framework::dataset::make("DataType", + DataType::QSYMM16)); const auto ElementwiseSquaredDiffS16Dataset = combine(combine(framework::dataset::make("DataType", { DataType::U8, DataType::S16 }), framework::dataset::make("DataType", DataType::S16)), framework::dataset::make("DataType", DataType::S16)); const auto ElementwiseSquaredDiffFP16Dataset = combine(combine(framework::dataset::make("DataType", DataType::F16), framework::dataset::make("DataType", DataType::F16)), @@ -97,6 +101,7 @@ DATA_TEST_CASE(Validate, framework::DatasetMode::ALL, zip(zip(zip( template using CLElementwiseSquaredDiffFixture = ElementwiseSquaredDiffValidationFixture; +TEST_SUITE(Integer) TEST_SUITE(U8) DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, datasets::SmallShapes(), shape) @@ -107,8 +112,8 @@ DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, datasets::SmallShapes CLTensor dst = create_tensor(shape, DataType::U8); // Create and Configure function - CLElementwiseSquaredDiff add; - add.configure(&ref_src1, &ref_src2, &dst); + CLElementwiseSquaredDiff sqdiff; + sqdiff.configure(&ref_src1, &ref_src2, &dst); // Validate valid region const ValidRegion valid_region = shape_to_valid_region(shape); @@ -128,6 +133,38 @@ FIXTURE_DATA_TEST_CASE(RunSmall, CLElementwiseSquaredDiffFixture, frame } TEST_SUITE_END() +TEST_SUITE(S16) +DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), framework::dataset::make("DataType", { DataType::U8, DataType::S16 })), + shape, data_type) +{ + // Create tensors + CLTensor ref_src1 = create_tensor(shape, data_type); + CLTensor ref_src2 = create_tensor(shape, DataType::S16); + CLTensor dst = create_tensor(shape, DataType::S16); + + // Create and Configure function + CLElementwiseSquaredDiff sqdiff; + sqdiff.configure(&ref_src1, &ref_src2, &dst); + + // Validate valid region + const ValidRegion valid_region = shape_to_valid_region(shape); + validate(dst.info()->valid_region(), valid_region); + + // Validate padding + const PaddingSize padding = PaddingCalculator(shape.x(), num_elems_processed_per_iteration).required_padding(); + validate(ref_src1.info()->padding(), padding); + validate(ref_src2.info()->padding(), padding); + validate(dst.info()->padding(), padding); +} + +FIXTURE_DATA_TEST_CASE(RunSmall, CLElementwiseSquaredDiffFixture, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), ElementwiseSquaredDiffS16Dataset)) +{ + // Validate output + validate(CLAccessor(_target), _reference); +} +TEST_SUITE_END() +TEST_SUITE_END() + template using CLElementwiseSquaredDiffQuantizedFixture = ElementwiseSquaredDiffValidationQuantizedFixture; @@ -142,8 +179,8 @@ DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, datasets::SmallShapes CLTensor dst = create_tensor(shape, DataType::QASYMM8); // Create and Configure function - CLElementwiseSquaredDiff add; - add.configure(&ref_src1, &ref_src2, &dst); + CLElementwiseSquaredDiff sqdiff; + sqdiff.configure(&ref_src1, &ref_src2, &dst); // Validate valid region const ValidRegion valid_region = shape_to_valid_region(shape); @@ -158,30 +195,26 @@ DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, datasets::SmallShapes FIXTURE_DATA_TEST_CASE(RunSmall, CLElementwiseSquaredDiffQuantizedFixture, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(), ElementwiseSquaredDiffQASYMM8Dataset), - framework::dataset::make("QuantizationInfo", { QuantizationInfo(5.f / 255.f, 20) })), - framework::dataset::make("QuantizationInfo", { QuantizationInfo(2.f / 255.f, 10) })), - framework::dataset::make("QuantizationInfo", { QuantizationInfo(1.f / 255.f, 5) })) - - ) + framework::dataset::make("Src0QInfo", { QuantizationInfo(5.f / 255.f, 20) })), + framework::dataset::make("Src1QInfo", { QuantizationInfo(2.f / 255.f, 10) })), + framework::dataset::make("OutQInfo", { QuantizationInfo(1.f / 255.f, 5) }))) { // Validate output validate(CLAccessor(_target), _reference, tolerance_fp32, 0.01); } TEST_SUITE_END() -TEST_SUITE_END() - -TEST_SUITE(S16) -DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), framework::dataset::make("DataType", { DataType::U8, DataType::S16 })), - shape, data_type) +TEST_SUITE(QSYMM16) +DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, datasets::SmallShapes(), + shape) { // Create tensors - CLTensor ref_src1 = create_tensor(shape, data_type); - CLTensor ref_src2 = create_tensor(shape, DataType::S16); - CLTensor dst = create_tensor(shape, DataType::S16); + CLTensor ref_src1 = create_tensor(shape, DataType::QSYMM16); + CLTensor ref_src2 = create_tensor(shape, DataType::QSYMM16); + CLTensor dst = create_tensor(shape, DataType::QSYMM16); // Create and Configure function - CLElementwiseSquaredDiff add; - add.configure(&ref_src1, &ref_src2, &dst); + CLElementwiseSquaredDiff sqdiff; + sqdiff.configure(&ref_src1, &ref_src2, &dst); // Validate valid region const ValidRegion valid_region = shape_to_valid_region(shape); @@ -194,12 +227,17 @@ DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(datasets::Sma validate(dst.info()->padding(), padding); } -FIXTURE_DATA_TEST_CASE(RunSmall, CLElementwiseSquaredDiffFixture, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), ElementwiseSquaredDiffS16Dataset)) +FIXTURE_DATA_TEST_CASE(RunSmall, CLElementwiseSquaredDiffQuantizedFixture, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(), + ElementwiseSquaredDiffQSYMM16Dataset), + framework::dataset::make("Src0QInfo", { QuantizationInfo(1.f / 32768.f, 0), QuantizationInfo(5.f / 32768.f, 0) })), + framework::dataset::make("Src1QInfo", { QuantizationInfo(2.f / 32768.f, 0), QuantizationInfo(5.f / 32768.f, 0) })), + framework::dataset::make("OutQInfo", { QuantizationInfo(5.f / 32768.f, 0) }))) { // Validate output - validate(CLAccessor(_target), _reference); + validate(CLAccessor(_target), _reference, tolerance_qsymm16); } TEST_SUITE_END() +TEST_SUITE_END() TEST_SUITE(Float) TEST_SUITE(FP16) @@ -220,8 +258,8 @@ DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, datasets::SmallShapes CLTensor dst = create_tensor(shape, DataType::F32); // Create and Configure function - CLElementwiseSquaredDiff add; - add.configure(&ref_src1, &ref_src2, &dst); + CLElementwiseSquaredDiff sqdiff; + sqdiff.configure(&ref_src1, &ref_src2, &dst); // Validate valid region const ValidRegion valid_region = shape_to_valid_region(shape); @@ -251,8 +289,8 @@ FIXTURE_DATA_TEST_CASE(RunSmallBroadcast, CLElementwiseSquaredDiffBroadcastFixtu TEST_SUITE_END() TEST_SUITE_END() -TEST_SUITE_END() -TEST_SUITE_END() +TEST_SUITE_END() // ElementwiseSquaredDiff +TEST_SUITE_END() // CL } // namespace validation } // namespace test } // namespace arm_compute diff --git a/tests/validation/reference/ElementwiseOperations.cpp b/tests/validation/reference/ElementwiseOperations.cpp index 44eb417969..d5a37a0fae 100644 --- a/tests/validation/reference/ElementwiseOperations.cpp +++ b/tests/validation/reference/ElementwiseOperations.cpp @@ -184,10 +184,39 @@ SimpleTensor arithmetic_operation(ArithmeticOperation op, const SimpleT } } +template <> +SimpleTensor arithmetic_operation(ArithmeticOperation op, const SimpleTensor &src1, const SimpleTensor &src2, SimpleTensor &dst, ConvertPolicy convert_policy) +{ + if(dst.data_type() == DataType::QSYMM16) + { + SimpleTensor src1_tmp = convert_from_symmetric(src1); + SimpleTensor src2_tmp = convert_from_symmetric(src2); + SimpleTensor dst_tmp(TensorShape::broadcast_shape(src1.shape(), src2.shape()), dst.data_type()); + + Coordinates id_src1{}; + Coordinates id_src2{}; + Coordinates id_dst{}; + + BroadcastUnroll::unroll(op, src1_tmp, src2_tmp, dst_tmp, convert_policy, id_src1, id_src2, id_dst); + + dst = convert_to_symmetric(dst_tmp, dst.quantization_info()); + return dst; + } + else + { + // DataType::S16 + Coordinates id_src1{}; + Coordinates id_src2{}; + Coordinates id_dst{}; + + BroadcastUnroll::unroll(op, src1, src2, dst, convert_policy, id_src1, id_src2, id_dst); + + return dst; + } +} + template SimpleTensor arithmetic_operation(ArithmeticOperation op, const SimpleTensor &src1, const SimpleTensor &src2, SimpleTensor &dst, ConvertPolicy convert_policy); -template SimpleTensor arithmetic_operation(ArithmeticOperation op, const SimpleTensor &src1, const SimpleTensor &src2, SimpleTensor &dst, - ConvertPolicy convert_policy); template SimpleTensor arithmetic_operation(ArithmeticOperation op, const SimpleTensor &src1, const SimpleTensor &src2, SimpleTensor &dst, ConvertPolicy convert_policy); template SimpleTensor arithmetic_operation(ArithmeticOperation op, const SimpleTensor &src1, const SimpleTensor &src2, SimpleTensor &dst, ConvertPolicy convert_policy); @@ -196,7 +225,7 @@ template SimpleTensor arithmetic_operation(ArithmeticOperation op, const template SimpleTensor arithmetic_operation(ArithmeticOperation op, const SimpleTensor &src1, const SimpleTensor &src2, DataType dst_data_type, ConvertPolicy convert_policy) { - ARM_COMPUTE_ERROR_ON_MSG(dst_data_type == DataType::QASYMM8, "For QASYMM8, the quantized output tensor should be passed directly."); + ARM_COMPUTE_ERROR_ON_MSG(is_data_type_quantized(dst_data_type), "For quantized data types, the quantized output tensor should be passed directly."); SimpleTensor dst(TensorShape::broadcast_shape(src1.shape(), src2.shape()), dst_data_type); arithmetic_operation(op, src1, src2, dst, convert_policy); -- cgit v1.2.1