From 303f0dbebf631b3db00d9d64e71018abbbe9d4fe Mon Sep 17 00:00:00 2001 From: Georgios Pinitas Date: Mon, 19 Nov 2018 11:56:51 +0000 Subject: COMPMID-1718: Extend DepthConvert to support Cast Change-Id: I6ee2c0b670727fc808fa636c53ddfaec3a0036c9 --- tests/validation/CL/Cast.cpp | 244 +++++++++++++++++++++++ tests/validation/CL/DepthConvertLayer.cpp | 78 -------- tests/validation/fixtures/CastFixture.h | 144 +++++++++++++ tests/validation/reference/DepthConvertLayer.cpp | 99 +++++++-- tests/validation/reference/DepthConvertLayer.h | 4 +- 5 files changed, 467 insertions(+), 102 deletions(-) create mode 100644 tests/validation/CL/Cast.cpp create mode 100644 tests/validation/fixtures/CastFixture.h (limited to 'tests/validation') diff --git a/tests/validation/CL/Cast.cpp b/tests/validation/CL/Cast.cpp new file mode 100644 index 0000000000..107edcd11e --- /dev/null +++ b/tests/validation/CL/Cast.cpp @@ -0,0 +1,244 @@ +/* + * Copyright (c) 2018 ARM Limited. + * + * SPDX-License-Identifier: MIT + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONCLCTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#include "arm_compute/core/Types.h" +#include "arm_compute/runtime/CL/CLTensor.h" +#include "arm_compute/runtime/CL/CLTensorAllocator.h" +#include "arm_compute/runtime/CL/functions/CLCast.h" +#include "tests/CL/CLAccessor.h" +#include "tests/PaddingCalculator.h" +#include "tests/datasets/ConvertPolicyDataset.h" +#include "tests/datasets/ShapeDatasets.h" +#include "tests/framework/Asserts.h" +#include "tests/framework/Macros.h" +#include "tests/framework/datasets/Datasets.h" +#include "tests/validation/Validation.h" +#include "tests/validation/fixtures/CastFixture.h" + +namespace arm_compute +{ +namespace test +{ +namespace validation +{ +namespace +{ +// Tolerance +constexpr AbsoluteTolerance one_tolerance(1); +constexpr AbsoluteTolerance zero_tolerance(0); + +/** Input data sets **/ +// U8 +const auto CastU8toS8Dataset = combine(framework::dataset::make("DataType", DataType::U8), framework::dataset::make("DataType", DataType::S8)); +const auto CastU8toU16Dataset = combine(framework::dataset::make("DataType", DataType::U8), framework::dataset::make("DataType", DataType::U16)); +const auto CastU8toS16Dataset = combine(framework::dataset::make("DataType", DataType::U8), framework::dataset::make("DataType", DataType::S16)); +const auto CastU8toU32Dataset = combine(framework::dataset::make("DataType", DataType::U8), framework::dataset::make("DataType", DataType::U32)); +const auto CastU8toS32Dataset = combine(framework::dataset::make("DataType", DataType::U8), framework::dataset::make("DataType", DataType::S32)); +const auto CastU8toF16Dataset = combine(framework::dataset::make("DataType", DataType::U8), framework::dataset::make("DataType", DataType::F16)); +const auto CastU8toF32Dataset = combine(framework::dataset::make("DataType", DataType::U8), framework::dataset::make("DataType", DataType::F32)); + +// S8 +const auto CastS8toU8Dataset = combine(framework::dataset::make("DataType", DataType::S8), framework::dataset::make("DataType", DataType::U8)); +const auto CastS8toU16Dataset = combine(framework::dataset::make("DataType", DataType::S8), framework::dataset::make("DataType", DataType::U16)); +const auto CastS8toS16Dataset = combine(framework::dataset::make("DataType", DataType::S8), framework::dataset::make("DataType", DataType::S16)); +const auto CastS8toU32Dataset = combine(framework::dataset::make("DataType", DataType::S8), framework::dataset::make("DataType", DataType::U32)); +const auto CastS8toS32Dataset = combine(framework::dataset::make("DataType", DataType::S8), framework::dataset::make("DataType", DataType::S32)); +const auto CastS8toF16Dataset = combine(framework::dataset::make("DataType", DataType::S8), framework::dataset::make("DataType", DataType::F16)); +const auto CastS8toF32Dataset = combine(framework::dataset::make("DataType", DataType::S8), framework::dataset::make("DataType", DataType::F32)); + +// U16 +const auto CastU16toU8Dataset = combine(framework::dataset::make("DataType", DataType::U16), framework::dataset::make("DataType", DataType::U8)); +const auto CastU16toS8Dataset = combine(framework::dataset::make("DataType", DataType::U16), framework::dataset::make("DataType", DataType::S8)); +const auto CastU16toS16Dataset = combine(framework::dataset::make("DataType", DataType::U16), framework::dataset::make("DataType", DataType::S16)); +const auto CastU16toU32Dataset = combine(framework::dataset::make("DataType", DataType::U16), framework::dataset::make("DataType", DataType::U32)); +const auto CastU16toS32Dataset = combine(framework::dataset::make("DataType", DataType::U16), framework::dataset::make("DataType", DataType::S32)); +const auto CastU16toF16Dataset = combine(framework::dataset::make("DataType", DataType::U16), framework::dataset::make("DataType", DataType::F16)); +const auto CastU16toF32Dataset = combine(framework::dataset::make("DataType", DataType::U16), framework::dataset::make("DataType", DataType::F32)); + +// S16 +const auto CastS16toU8Dataset = combine(framework::dataset::make("DataType", DataType::S16), framework::dataset::make("DataType", DataType::U8)); +const auto CastS16toS8Dataset = combine(framework::dataset::make("DataType", DataType::S16), framework::dataset::make("DataType", DataType::S8)); +const auto CastS16toU16Dataset = combine(framework::dataset::make("DataType", DataType::S16), framework::dataset::make("DataType", DataType::U16)); +const auto CastS16toU32Dataset = combine(framework::dataset::make("DataType", DataType::S16), framework::dataset::make("DataType", DataType::U32)); +const auto CastS16toS32Dataset = combine(framework::dataset::make("DataType", DataType::S16), framework::dataset::make("DataType", DataType::S32)); +const auto CastS16toF16Dataset = combine(framework::dataset::make("DataType", DataType::S16), framework::dataset::make("DataType", DataType::F16)); +const auto CastS16toF32Dataset = combine(framework::dataset::make("DataType", DataType::S16), framework::dataset::make("DataType", DataType::F32)); + +// U32 +const auto CastU32toU8Dataset = combine(framework::dataset::make("DataType", DataType::U32), framework::dataset::make("DataType", DataType::U8)); +const auto CastU32toS8Dataset = combine(framework::dataset::make("DataType", DataType::U32), framework::dataset::make("DataType", DataType::S8)); +const auto CastU32toU16Dataset = combine(framework::dataset::make("DataType", DataType::U32), framework::dataset::make("DataType", DataType::U16)); +const auto CastU32toS16Dataset = combine(framework::dataset::make("DataType", DataType::U32), framework::dataset::make("DataType", DataType::S16)); +const auto CastU32toS32Dataset = combine(framework::dataset::make("DataType", DataType::U32), framework::dataset::make("DataType", DataType::S32)); +const auto CastU32toF16Dataset = combine(framework::dataset::make("DataType", DataType::U32), framework::dataset::make("DataType", DataType::F16)); +const auto CastU32toF32Dataset = combine(framework::dataset::make("DataType", DataType::U32), framework::dataset::make("DataType", DataType::F32)); + +// S32 +const auto CastS32toU8Dataset = combine(framework::dataset::make("DataType", DataType::S32), framework::dataset::make("DataType", DataType::U8)); +const auto CastS32toS8Dataset = combine(framework::dataset::make("DataType", DataType::S32), framework::dataset::make("DataType", DataType::S8)); +const auto CastS32toU16Dataset = combine(framework::dataset::make("DataType", DataType::S32), framework::dataset::make("DataType", DataType::U16)); +const auto CastS32toS16Dataset = combine(framework::dataset::make("DataType", DataType::S32), framework::dataset::make("DataType", DataType::S16)); +const auto CastS32toU32Dataset = combine(framework::dataset::make("DataType", DataType::S32), framework::dataset::make("DataType", DataType::U32)); +const auto CastS32toF16Dataset = combine(framework::dataset::make("DataType", DataType::S32), framework::dataset::make("DataType", DataType::F16)); +const auto CastS32toF32Dataset = combine(framework::dataset::make("DataType", DataType::S32), framework::dataset::make("DataType", DataType::F32)); + +// F16 +const auto CastF16toU8Dataset = combine(framework::dataset::make("DataType", DataType::F16), framework::dataset::make("DataType", DataType::U8)); +const auto CastF16toS8Dataset = combine(framework::dataset::make("DataType", DataType::F16), framework::dataset::make("DataType", DataType::S8)); +const auto CastF16toU16Dataset = combine(framework::dataset::make("DataType", DataType::F16), framework::dataset::make("DataType", DataType::U16)); +const auto CastF16toS16Dataset = combine(framework::dataset::make("DataType", DataType::F16), framework::dataset::make("DataType", DataType::S16)); +const auto CastF16toU32Dataset = combine(framework::dataset::make("DataType", DataType::F16), framework::dataset::make("DataType", DataType::U32)); +const auto CastF16toS32Dataset = combine(framework::dataset::make("DataType", DataType::F16), framework::dataset::make("DataType", DataType::S32)); +const auto CastF16toF32Dataset = combine(framework::dataset::make("DataType", DataType::F16), framework::dataset::make("DataType", DataType::F32)); + +// F32 +const auto CastF32toU8Dataset = combine(framework::dataset::make("DataType", DataType::F32), framework::dataset::make("DataType", DataType::U8)); +const auto CastF32toS8Dataset = combine(framework::dataset::make("DataType", DataType::F32), framework::dataset::make("DataType", DataType::S8)); +const auto CastF32toU16Dataset = combine(framework::dataset::make("DataType", DataType::F32), framework::dataset::make("DataType", DataType::U16)); +const auto CastF32toS16Dataset = combine(framework::dataset::make("DataType", DataType::F32), framework::dataset::make("DataType", DataType::S16)); +const auto CastF32toU32Dataset = combine(framework::dataset::make("DataType", DataType::F32), framework::dataset::make("DataType", DataType::U32)); +const auto CastF32toS32Dataset = combine(framework::dataset::make("DataType", DataType::F32), framework::dataset::make("DataType", DataType::S32)); +const auto CastF32toF16Dataset = combine(framework::dataset::make("DataType", DataType::F32), framework::dataset::make("DataType", DataType::F16)); +} // namespace + +TEST_SUITE(CL) +TEST_SUITE(Cast) +template +using CLCastToU8Fixture = CastValidationFixture; +template +using CLCastToS8Fixture = CastValidationFixture; +template +using CLCastToU16Fixture = CastValidationFixture; +template +using CLCastToS16Fixture = CastValidationFixture; +template +using CLCastToU32Fixture = CastValidationFixture; +template +using CLCastToS32Fixture = CastValidationFixture; +template +using CLCastToF16Fixture = CastValidationFixture; +template +using CLCastToF32Fixture = CastValidationFixture; + +#define CAST_SUITE(NAME, idt, odt, type, dataset, tolerance) \ + TEST_SUITE(NAME) \ + DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(datasets::SmallShapes(), datasets::ConvertPolicies()), \ + shape, policy) \ + { \ + CLTensor src = create_tensor(shape, idt, 1); \ + CLTensor dst = create_tensor(shape, odt, 1); \ + \ + CLCast cast; \ + cast.configure(&src, &dst, policy); \ + \ + const ValidRegion valid_region = shape_to_valid_region(shape); \ + validate(dst.info()->valid_region(), valid_region); \ + \ + const PaddingSize padding = PaddingCalculator(shape.x(), 16).required_padding(); \ + validate(src.info()->padding(), padding); \ + validate(dst.info()->padding(), padding); \ + } \ + FIXTURE_DATA_TEST_CASE(RunSmall, type, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), dataset), \ + datasets::ConvertPolicies())) \ + { \ + validate(CLAccessor(_target), _reference, tolerance); \ + } \ + TEST_SUITE_END() + +// U8 +CAST_SUITE(U8_to_S8, DataType::U8, DataType::S8, CLCastToS8Fixture, CastU8toS8Dataset, zero_tolerance) +CAST_SUITE(U8_to_U16, DataType::U8, DataType::U16, CLCastToU16Fixture, CastU8toU16Dataset, zero_tolerance) +CAST_SUITE(U8_to_S16, DataType::U8, DataType::S16, CLCastToS16Fixture, CastU8toS16Dataset, zero_tolerance) +CAST_SUITE(U8_to_U32, DataType::U8, DataType::U32, CLCastToU32Fixture, CastU8toU32Dataset, zero_tolerance) +CAST_SUITE(U8_to_S32, DataType::U8, DataType::S32, CLCastToS32Fixture, CastU8toS32Dataset, zero_tolerance) +CAST_SUITE(U8_to_F16, DataType::U8, DataType::F16, CLCastToF16Fixture, CastU8toF16Dataset, zero_tolerance) +CAST_SUITE(U8_to_F32, DataType::U8, DataType::F32, CLCastToF32Fixture, CastU8toF32Dataset, zero_tolerance) + +// S8 +CAST_SUITE(S8_to_U8, DataType::S8, DataType::U8, CLCastToU8Fixture, CastS8toU8Dataset, zero_tolerance) +CAST_SUITE(S8_to_U16, DataType::S8, DataType::U16, CLCastToU16Fixture, CastS8toU16Dataset, zero_tolerance) +CAST_SUITE(S8_to_S16, DataType::S8, DataType::S16, CLCastToS16Fixture, CastS8toS16Dataset, zero_tolerance) +CAST_SUITE(S8_to_U32, DataType::S8, DataType::U32, CLCastToU32Fixture, CastS8toU32Dataset, zero_tolerance) +CAST_SUITE(S8_to_S32, DataType::S8, DataType::S32, CLCastToS32Fixture, CastS8toS32Dataset, zero_tolerance) +CAST_SUITE(S8_to_F16, DataType::S8, DataType::F16, CLCastToF16Fixture, CastS8toF16Dataset, zero_tolerance) +CAST_SUITE(S8_to_F32, DataType::S8, DataType::F32, CLCastToF32Fixture, CastS8toF32Dataset, zero_tolerance) + +// U16 +CAST_SUITE(U16_to_U8, DataType::U16, DataType::U8, CLCastToU8Fixture, CastU16toU8Dataset, zero_tolerance) +CAST_SUITE(U16_to_S8, DataType::U16, DataType::S8, CLCastToS8Fixture, CastU16toS8Dataset, zero_tolerance) +CAST_SUITE(U16_to_S16, DataType::U16, DataType::S16, CLCastToS16Fixture, CastU16toS16Dataset, zero_tolerance) +CAST_SUITE(U16_to_U32, DataType::U16, DataType::U32, CLCastToU32Fixture, CastU16toU32Dataset, zero_tolerance) +CAST_SUITE(U16_to_S32, DataType::U16, DataType::S32, CLCastToS32Fixture, CastU16toS32Dataset, zero_tolerance) +CAST_SUITE(U16_to_F16, DataType::U16, DataType::F16, CLCastToF16Fixture, CastU16toF16Dataset, zero_tolerance) +CAST_SUITE(U16_to_F32, DataType::U16, DataType::F32, CLCastToF32Fixture, CastU16toF32Dataset, zero_tolerance) + +// S16 +CAST_SUITE(S16_to_U8, DataType::S16, DataType::U8, CLCastToU8Fixture, CastS16toU8Dataset, zero_tolerance) +CAST_SUITE(S16_to_S8, DataType::S16, DataType::S8, CLCastToS8Fixture, CastS16toS8Dataset, zero_tolerance) +CAST_SUITE(S16_to_U16, DataType::S16, DataType::U16, CLCastToU16Fixture, CastS16toU16Dataset, zero_tolerance) +CAST_SUITE(S16_to_U32, DataType::S16, DataType::U32, CLCastToU32Fixture, CastS16toU32Dataset, zero_tolerance) +CAST_SUITE(S16_to_S32, DataType::S16, DataType::S32, CLCastToS32Fixture, CastS16toS32Dataset, zero_tolerance) +CAST_SUITE(S16_to_F16, DataType::S16, DataType::F16, CLCastToF16Fixture, CastS16toF16Dataset, zero_tolerance) +CAST_SUITE(S16_to_F32, DataType::S16, DataType::F32, CLCastToF32Fixture, CastS16toF32Dataset, zero_tolerance) + +// U32 +CAST_SUITE(U32_to_U8, DataType::U32, DataType::U8, CLCastToU8Fixture, CastU32toU8Dataset, zero_tolerance) +CAST_SUITE(U32_to_S8, DataType::U32, DataType::S8, CLCastToS8Fixture, CastU32toS8Dataset, zero_tolerance) +CAST_SUITE(U32_to_U16, DataType::U32, DataType::U16, CLCastToU16Fixture, CastU32toU16Dataset, zero_tolerance) +CAST_SUITE(U32_to_S16, DataType::U32, DataType::S16, CLCastToS16Fixture, CastU32toS16Dataset, zero_tolerance) +CAST_SUITE(U32_to_S32, DataType::U32, DataType::S32, CLCastToS32Fixture, CastU32toS32Dataset, zero_tolerance) +CAST_SUITE(U32_to_F16, DataType::U32, DataType::F16, CLCastToF16Fixture, CastU32toF16Dataset, zero_tolerance) +CAST_SUITE(U32_to_F32, DataType::U32, DataType::F32, CLCastToF32Fixture, CastU32toF32Dataset, zero_tolerance) + +// S32 +CAST_SUITE(S32_to_U8, DataType::S32, DataType::U8, CLCastToU8Fixture, CastS32toU8Dataset, zero_tolerance) +CAST_SUITE(S32_to_S8, DataType::S32, DataType::S8, CLCastToS8Fixture, CastS32toS8Dataset, zero_tolerance) +CAST_SUITE(S32_to_U16, DataType::S32, DataType::U16, CLCastToU16Fixture, CastS32toU16Dataset, zero_tolerance) +CAST_SUITE(S32_to_S16, DataType::S32, DataType::S16, CLCastToS16Fixture, CastS32toS16Dataset, zero_tolerance) +CAST_SUITE(S32_to_U32, DataType::S32, DataType::U32, CLCastToU32Fixture, CastS32toU32Dataset, zero_tolerance) +CAST_SUITE(S32_to_F16, DataType::S32, DataType::F16, CLCastToF16Fixture, CastS32toF16Dataset, zero_tolerance) +CAST_SUITE(S32_to_F32, DataType::S32, DataType::F32, CLCastToF32Fixture, CastS32toF32Dataset, zero_tolerance) + +// F16 +CAST_SUITE(F16_to_U8, DataType::F16, DataType::U8, CLCastToU8Fixture, CastF16toU8Dataset, one_tolerance) +CAST_SUITE(F16_to_S8, DataType::F16, DataType::S8, CLCastToS8Fixture, CastF16toS8Dataset, one_tolerance) +CAST_SUITE(F16_to_U16, DataType::F16, DataType::U16, CLCastToU16Fixture, CastF16toU16Dataset, one_tolerance) +CAST_SUITE(F16_to_S16, DataType::F16, DataType::S16, CLCastToS16Fixture, CastF16toS16Dataset, one_tolerance) +CAST_SUITE(F16_to_U32, DataType::F16, DataType::U32, CLCastToU32Fixture, CastF16toU32Dataset, one_tolerance) +CAST_SUITE(F16_to_S32, DataType::F16, DataType::S32, CLCastToS32Fixture, CastF16toS32Dataset, one_tolerance) +CAST_SUITE(F16_to_F32, DataType::F16, DataType::F32, CLCastToF32Fixture, CastF16toF32Dataset, one_tolerance) + +// F32 +CAST_SUITE(F32_to_U8, DataType::F32, DataType::U8, CLCastToU8Fixture, CastF32toU8Dataset, one_tolerance) +CAST_SUITE(F32_to_S8, DataType::F32, DataType::S8, CLCastToS8Fixture, CastF32toS8Dataset, one_tolerance) +CAST_SUITE(F32_to_U16, DataType::F32, DataType::U16, CLCastToU16Fixture, CastF32toU16Dataset, one_tolerance) +CAST_SUITE(F32_to_S16, DataType::F32, DataType::S16, CLCastToS16Fixture, CastF32toS16Dataset, one_tolerance) +CAST_SUITE(F32_to_U32, DataType::F32, DataType::U32, CLCastToU32Fixture, CastF32toU32Dataset, one_tolerance) +CAST_SUITE(F32_to_S32, DataType::F32, DataType::S32, CLCastToS32Fixture, CastF32toS32Dataset, one_tolerance) +CAST_SUITE(F32_to_F16, DataType::F32, DataType::F16, CLCastToF16Fixture, CastF32toF16Dataset, one_tolerance) + +TEST_SUITE_END() // Cast +TEST_SUITE_END() // CL +} // namespace validation +} // namespace test +} // namespace arm_compute diff --git a/tests/validation/CL/DepthConvertLayer.cpp b/tests/validation/CL/DepthConvertLayer.cpp index fe46313568..7d7b5f2176 100644 --- a/tests/validation/CL/DepthConvertLayer.cpp +++ b/tests/validation/CL/DepthConvertLayer.cpp @@ -348,84 +348,6 @@ FIXTURE_DATA_TEST_CASE(RunLarge, CLDepthConvertLayerToS32Fixture, frame } TEST_SUITE_END() -TEST_SUITE(F16_to_F32) -DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(framework::dataset::concat(datasets::SmallShapes(), datasets::LargeShapes()), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), - DepthConvertLayerShiftDataset), - shape, policy, shift) -{ - // Create tensors - CLTensor src = create_tensor(shape, DataType::F16, 1); - CLTensor dst = create_tensor(shape, DataType::F32, 1); - - // Create and Configure function - CLDepthConvertLayer depth_convert; - depth_convert.configure(&src, &dst, policy, shift); - - // 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(), 16).required_padding(); - validate(src.info()->padding(), padding); - validate(dst.info()->padding(), padding); -} - -FIXTURE_DATA_TEST_CASE(RunSmall, CLDepthConvertLayerToF32Fixture, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerF16toF32Dataset), - framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), - DepthConvertLayerShiftDataset)) -{ - // Validate output - validate(CLAccessor(_target), _reference); -} -FIXTURE_DATA_TEST_CASE(RunLarge, CLDepthConvertLayerToF32Fixture, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerF16toF32Dataset), - framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), - DepthConvertLayerShiftDataset)) -{ - // Validate output - validate(CLAccessor(_target), _reference); -} -TEST_SUITE_END() - -TEST_SUITE(F32_to_F16) -DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(framework::dataset::concat(datasets::SmallShapes(), datasets::LargeShapes()), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), - DepthConvertLayerShiftDataset), - shape, policy, shift) -{ - // Create tensors - CLTensor src = create_tensor(shape, DataType::F32, 1); - CLTensor dst = create_tensor(shape, DataType::F16, 1); - - // Create and Configure function - CLDepthConvertLayer depth_convert; - depth_convert.configure(&src, &dst, policy, shift); - - // 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(), 16).required_padding(); - validate(src.info()->padding(), padding); - validate(dst.info()->padding(), padding); -} - -FIXTURE_DATA_TEST_CASE(RunSmall, CLDepthConvertLayerToF16Fixture, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerF32toF16Dataset), - framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), - DepthConvertLayerShiftDataset)) -{ - // Validate output - validate(CLAccessor(_target), _reference); -} -FIXTURE_DATA_TEST_CASE(RunLarge, CLDepthConvertLayerToF16Fixture, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerF32toF16Dataset), - framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })), - DepthConvertLayerShiftDataset)) -{ - // Validate output - validate(CLAccessor(_target), _reference); -} -TEST_SUITE_END() - TEST_SUITE_END() TEST_SUITE_END() } // namespace validation diff --git a/tests/validation/fixtures/CastFixture.h b/tests/validation/fixtures/CastFixture.h new file mode 100644 index 0000000000..3a6efa22af --- /dev/null +++ b/tests/validation/fixtures/CastFixture.h @@ -0,0 +1,144 @@ +/* + * Copyright (c) 2018 ARM Limited. + * + * SPDX-License-Identifier: MIT + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#ifndef ARM_COMPUTE_TEST_CAST_FIXTURE +#define ARM_COMPUTE_TEST_CAST_FIXTURE + +#include "tests/validation/fixtures/DepthConvertLayerFixture.h" + +namespace arm_compute +{ +namespace test +{ +namespace validation +{ +template +class CastValidationFixture : public framework::Fixture +{ +public: + template + void setup(TensorShape shape, DataType dt_in, DataType dt_out, ConvertPolicy policy) + { + _target = compute_target(shape, dt_in, dt_out, policy); + _reference = compute_reference(shape, dt_in, dt_out, policy); + } + +protected: + template + void fill(U &&tensor, int i, DataType dt_in, DataType dt_out) + { + // Restricting range to avoid inf values + if(dt_out == DataType::F16) + { + const int signed_min = -32000; + const int signed_max = 32000; + const int unsigned_min = 0; + const int unsigned_max = 65000; + + switch(dt_in) + { + case DataType::U8: + case DataType::QASYMM8: + case DataType::S8: + case DataType::F32: + { + library->fill_tensor_uniform(tensor, i); + break; + } + case DataType::U16: + { + library->fill_tensor_uniform(tensor, i, static_cast(unsigned_min), static_cast(unsigned_max)); + break; + } + case DataType::S16: + { + library->fill_tensor_uniform(tensor, i, static_cast(signed_min), static_cast(signed_max)); + break; + } + case DataType::U32: + { + library->fill_tensor_uniform(tensor, i, static_cast(unsigned_min), static_cast(unsigned_max)); + break; + } + case DataType::S32: + { + library->fill_tensor_uniform(tensor, i, static_cast(signed_min), static_cast(signed_max)); + break; + } + default: + ARM_COMPUTE_ERROR("NOT SUPPORTED!"); + } + } + else + { + library->fill_tensor_uniform(tensor, i); + } + } + + TensorType compute_target(const TensorShape &shape, DataType dt_in, DataType dt_out, ConvertPolicy policy) + { + // Create tensors + TensorType src = create_tensor(shape, dt_in, 1); + TensorType dst = create_tensor(shape, dt_out, 1); + + // Create and configure function + FunctionType cast; + cast.configure(&src, &dst, policy); + + ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS); + ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS); + + // Allocate tensors + src.allocator()->allocate(); + dst.allocator()->allocate(); + + ARM_COMPUTE_EXPECT(!src.info()->is_resizable(), framework::LogLevel::ERRORS); + ARM_COMPUTE_EXPECT(!dst.info()->is_resizable(), framework::LogLevel::ERRORS); + + // Fill tensors + fill(AccessorType(src), 0, dt_in, dt_out); + + // Compute function + cast.run(); + + return dst; + } + + SimpleTensor compute_reference(const TensorShape &shape, DataType dt_in, DataType dt_out, ConvertPolicy policy) + { + // Create reference + SimpleTensor src{ shape, dt_in, 1 }; + + // Fill reference + fill(src, 0, dt_in, dt_out); + + return reference::depth_convert(src, dt_out, policy, 0); + } + + TensorType _target{}; + SimpleTensor _reference{}; +}; +} // namespace validation +} // namespace test +} // namespace arm_compute +#endif /* ARM_COMPUTE_TEST_CAST_FIXTURE */ diff --git a/tests/validation/reference/DepthConvertLayer.cpp b/tests/validation/reference/DepthConvertLayer.cpp index fd2e0ae378..4d5b97b478 100644 --- a/tests/validation/reference/DepthConvertLayer.cpp +++ b/tests/validation/reference/DepthConvertLayer.cpp @@ -25,6 +25,9 @@ #include "tests/validation/Helpers.h" +#include "arm_compute/core/utils/misc/Rounding.h" +#include "arm_compute/core/utils/misc/SaturateCast.h" + #include "tests/Types.h" namespace arm_compute @@ -35,13 +38,13 @@ namespace validation { namespace reference { -template < typename T1, typename T2, typename std::enable_if < std::is_integral::value &&std::is_integral::value &&!std::is_same::value, int >::type > +template < typename T1, typename T2, typename std::enable_if < std::is_integral::value &&!std::is_same::value, int >::type > SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift) { SimpleTensor result(src.shape(), dt_out); // Up-casting - if(src.data_type() <= dt_out) + if(element_size_from_data_type(src.data_type()) < element_size_from_data_type(dt_out)) { for(int i = 0; i < src.num_elements(); ++i) { @@ -54,48 +57,100 @@ SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, Con for(int i = 0; i < src.num_elements(); ++i) { T1 val = src[i] >> shift; - result[i] = (policy == ConvertPolicy::SATURATE) ? saturate_cast(val) : static_cast(val); + result[i] = (policy == ConvertPolicy::SATURATE) ? utils::cast::saturate_cast(val) : static_cast(val); } } return result; } -template < typename T1, typename T2, typename std::enable_if < is_floating_point::value &&is_floating_point::value &&!std::is_same::value, int >::type > +template < typename T1, typename T2, typename std::enable_if < is_floating_point::value &&!std::is_same::value, int >::type > SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift) { SimpleTensor result(src.shape(), dt_out); + ARM_COMPUTE_ERROR_ON(shift != 0); + ARM_COMPUTE_UNUSED(policy, shift); - const uint32_t scale = 1 << shift; - - // Up-casting - if(src.data_type() <= dt_out) + // Always saturate on floats + for(int i = 0; i < src.num_elements(); ++i) { - for(int i = 0; i < src.num_elements(); ++i) - { - result[i] = src[i] * static_cast(scale); - } - } - // Down-casting - else - { - for(int i = 0; i < src.num_elements(); ++i) - { - T1 val = src[i] / static_cast(scale); - result[i] = (policy == ConvertPolicy::SATURATE) ? saturate_cast(val) : static_cast(val); - } + T1 val = utils::rounding::round_half_away_from_zero(src[i]); + result[i] = utils::cast::saturate_cast(val); } return result; } +// U8 +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); + +// S8 +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); + +// U16 template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); + +// S16 template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); -template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); + +// U32 +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); + +// S32 +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); + +// F16 +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); + +// F32 +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); +template SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); + } // namespace reference } // namespace validation } // namespace test diff --git a/tests/validation/reference/DepthConvertLayer.h b/tests/validation/reference/DepthConvertLayer.h index 5d97c73b3c..2113593e9d 100644 --- a/tests/validation/reference/DepthConvertLayer.h +++ b/tests/validation/reference/DepthConvertLayer.h @@ -35,10 +35,10 @@ namespace validation { namespace reference { -template < typename T1, typename T2, typename std::enable_if < std::is_integral::value &&std::is_integral::value &&!std::is_same::value, int >::type = 0 > +template < typename T1, typename T2, typename std::enable_if < std::is_integral::value &&!std::is_same::value, int >::type = 0 > SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); -template < typename T1, typename T2, typename std::enable_if < is_floating_point::value &&is_floating_point::value &&!std::is_same::value, int >::type = 0 > +template < typename T1, typename T2, typename std::enable_if < is_floating_point::value &&!std::is_same::value, int >::type = 0 > SimpleTensor depth_convert(const SimpleTensor &src, DataType dt_out, ConvertPolicy policy, uint32_t shift); } // namespace reference } // namespace validation -- cgit v1.2.1