From 926d5e17d073cf7f0999d4ab4ce4f79f5391abb8 Mon Sep 17 00:00:00 2001 From: zhenglin Date: Thu, 21 Dec 2017 15:36:50 +0800 Subject: APPBROWSER-356: Implement GCArithmeticAddition Operator Change-Id: I4ce55e69b3a76ab3539955d5ad12a226159b1daa Reviewed-on: https://eu-gerrit-1.euhpc.arm.com/114222 Tested-by: Jenkins Reviewed-by: Pablo Tello --- arm_compute/core/GLES_COMPUTE/GCKernels.h | 1 + .../kernels/GCArithmeticAdditionKernel.h | 82 +++++++++++ arm_compute/runtime/GLES_COMPUTE/GCFunctions.h | 1 + .../GLES_COMPUTE/functions/GCArithmeticAddition.h | 62 +++++++++ src/core/GLES_COMPUTE/GCKernelLibrary.cpp | 5 + src/core/GLES_COMPUTE/cs_shaders/arithmetic_add.cs | 65 +++++++++ .../kernels/GCArithmeticAdditionKernel.cpp | 152 +++++++++++++++++++++ .../functions/GCArithmeticAddition.cpp | 43 ++++++ .../validation/GLES_COMPUTE/ArithmeticAddition.cpp | 72 ++++++++++ 9 files changed, 483 insertions(+) create mode 100644 arm_compute/core/GLES_COMPUTE/kernels/GCArithmeticAdditionKernel.h create mode 100644 arm_compute/runtime/GLES_COMPUTE/functions/GCArithmeticAddition.h create mode 100755 src/core/GLES_COMPUTE/cs_shaders/arithmetic_add.cs create mode 100644 src/core/GLES_COMPUTE/kernels/GCArithmeticAdditionKernel.cpp create mode 100755 src/runtime/GLES_COMPUTE/functions/GCArithmeticAddition.cpp create mode 100755 tests/validation/GLES_COMPUTE/ArithmeticAddition.cpp diff --git a/arm_compute/core/GLES_COMPUTE/GCKernels.h b/arm_compute/core/GLES_COMPUTE/GCKernels.h index 7af859ca7e..c6f4877fa1 100644 --- a/arm_compute/core/GLES_COMPUTE/GCKernels.h +++ b/arm_compute/core/GLES_COMPUTE/GCKernels.h @@ -27,6 +27,7 @@ /* Header regrouping all the GLES compute kernels */ #include "arm_compute/core/GLES_COMPUTE/kernels/GCAbsoluteDifferenceKernel.h" #include "arm_compute/core/GLES_COMPUTE/kernels/GCActivationLayerKernel.h" +#include "arm_compute/core/GLES_COMPUTE/kernels/GCArithmeticAdditionKernel.h" #include "arm_compute/core/GLES_COMPUTE/kernels/GCBatchNormalizationLayerKernel.h" #include "arm_compute/core/GLES_COMPUTE/kernels/GCCol2ImKernel.h" #include "arm_compute/core/GLES_COMPUTE/kernels/GCDepthConcatenateLayerKernel.h" diff --git a/arm_compute/core/GLES_COMPUTE/kernels/GCArithmeticAdditionKernel.h b/arm_compute/core/GLES_COMPUTE/kernels/GCArithmeticAdditionKernel.h new file mode 100644 index 0000000000..0bf88711c6 --- /dev/null +++ b/arm_compute/core/GLES_COMPUTE/kernels/GCArithmeticAdditionKernel.h @@ -0,0 +1,82 @@ +/* + * Copyright (c) 2016, 2017 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_GCARITHMETICADDITIONKERNEL_H__ +#define __ARM_COMPUTE_GCARITHMETICADDITIONKERNEL_H__ + +#include "arm_compute/core/GLES_COMPUTE/IGCKernel.h" +#include "arm_compute/core/Types.h" + +namespace arm_compute +{ +class IGCTensor; + +/** Interface for the arithmetic addition kernel + * + * Arithmetic addition is computed by: + * @f[ output(x,y) = input1(x,y) + input2(x,y) @f] + */ +class GCArithmeticAdditionKernel : public IGCKernel +{ +public: + /** Default constructor */ + GCArithmeticAdditionKernel(); + /** Prevent instances of this class from being copied (As this class contains pointers) */ + GCArithmeticAdditionKernel(const GCArithmeticAdditionKernel &) = delete; + /** Prevent instances of this class from being copied (As this class contains pointers) */ + GCArithmeticAdditionKernel &operator=(const GCArithmeticAdditionKernel &) = delete; + /** Allow instances of this class to be moved */ + GCArithmeticAdditionKernel(GCArithmeticAdditionKernel &&) = default; + /** Allow instances of this class to be moved */ + GCArithmeticAdditionKernel &operator=(GCArithmeticAdditionKernel &&) = default; + /** Default destructor */ + ~GCArithmeticAdditionKernel() = default; + /** Initialise the kernel's inputs, output and convertion policy. + * + * @param[in] input1 First tensor input. Data types supported: F16. + * @param[in] input2 Second tensor input. Data types supported: F16. + * @param[out] output Output tensor. Data types supported: F16. + * @param[in] policy Policy to use to handle overflow. + */ + void configure(const IGCTensor *input1, const IGCTensor *input2, IGCTensor *output, ConvertPolicy policy); + /** Static function to check if given info will lead to a valid configuration of @ref GCArithmeticAdditionKernel + * + * @param[in] input1 First tensor input info. Data types supported: F16. + * @param[in] input2 Second tensor input info. Data types supported: F16. + * @param[out] output Output tensor info. Data types supported: F16. + * @param[in] policy Policy to use to handle overflow. + * + * @return a status + */ + static Status validate(const ITensorInfo *input1, const ITensorInfo *input2, const ITensorInfo *output, ConvertPolicy policy); + + // Inherited methods overridden: + void run(const Window &window) override; + +private: + const IGCTensor *_input1; /**< Source tensor 1 */ + const IGCTensor *_input2; /**< Source tensor 2 */ + IGCTensor *_output; /**< Destination tensor */ +}; +} // namespace arm_compute +#endif /* __ARM_COMPUTE_GCARITHMETICADDITIONKERNEL_H__ */ diff --git a/arm_compute/runtime/GLES_COMPUTE/GCFunctions.h b/arm_compute/runtime/GLES_COMPUTE/GCFunctions.h index f05d3c7a97..faaf2f0edc 100644 --- a/arm_compute/runtime/GLES_COMPUTE/GCFunctions.h +++ b/arm_compute/runtime/GLES_COMPUTE/GCFunctions.h @@ -27,6 +27,7 @@ /* Header regrouping all the GLES compute functions */ #include "arm_compute/runtime/GLES_COMPUTE/functions/GCAbsoluteDifference.h" #include "arm_compute/runtime/GLES_COMPUTE/functions/GCActivationLayer.h" +#include "arm_compute/runtime/GLES_COMPUTE/functions/GCArithmeticAddition.h" #include "arm_compute/runtime/GLES_COMPUTE/functions/GCBatchNormalizationLayer.h" #include "arm_compute/runtime/GLES_COMPUTE/functions/GCDepthConcatenateLayer.h" #include "arm_compute/runtime/GLES_COMPUTE/functions/GCDirectConvolutionLayer.h" diff --git a/arm_compute/runtime/GLES_COMPUTE/functions/GCArithmeticAddition.h b/arm_compute/runtime/GLES_COMPUTE/functions/GCArithmeticAddition.h new file mode 100644 index 0000000000..721a9b4f2b --- /dev/null +++ b/arm_compute/runtime/GLES_COMPUTE/functions/GCArithmeticAddition.h @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2016, 2017 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_GCARITHMETICADDITION_H__ +#define __ARM_COMPUTE_GCARITHMETICADDITION_H__ + +#include "arm_compute/core/Types.h" +#include "arm_compute/runtime/GLES_COMPUTE/IGCSimpleFunction.h" + +namespace arm_compute +{ +class IGCTensor; + +/** Basic function to run @ref GCArithmeticAdditionKernel + * + * @note The tensor data type for the inputs must be F16. + * @note The function performs an arithmetic addition between two tensors. + */ +class GCArithmeticAddition : public IGCSimpleFunction +{ +public: + /** Initialise the kernel's inputs, output and convertion policy. + * + * @param[in] input1 First tensor input. Data types supported: F16. + * @param[in] input2 Second tensor input. Data types supported: F16. + * @param[out] output Output tensor. Data types supported: F16. + * @param[in] policy Policy to use to handle overflow. + */ + void configure(const IGCTensor *input1, const IGCTensor *input2, IGCTensor *output, ConvertPolicy policy); + /** Static function to check if given info will lead to a valid configuration of @ref GCArithmeticAddition + * + * @param[in] input1 First tensor input info. Data types supported: F16. + * @param[in] input2 Second tensor input info. Data types supported: F16. + * @param[in] output Output tensor info. Data types supported: F16. + * @param[in] policy Policy to use to handle overflow. + * + * @return a status + */ + static Status validate(const ITensorInfo *input1, const ITensorInfo *input2, const ITensorInfo *output, ConvertPolicy policy); +}; +} +#endif /* __ARM_COMPUTE_GCARITHMETICADDITION_H__ */ diff --git a/src/core/GLES_COMPUTE/GCKernelLibrary.cpp b/src/core/GLES_COMPUTE/GCKernelLibrary.cpp index dd040e39e2..26b8aaafd6 100644 --- a/src/core/GLES_COMPUTE/GCKernelLibrary.cpp +++ b/src/core/GLES_COMPUTE/GCKernelLibrary.cpp @@ -222,6 +222,7 @@ const std::map GCKernelLibrary::_shader_program_map = { "dropout", "dropout.cs" }, { "normalize_planar_yuv_layer", "normalize_planar_yuv_layer.cs" }, { "scale_nearest_neighbour", "scale.cs" }, + { "arithmetic_add", "arithmetic_add.cs" }, }; const std::map GCKernelLibrary::_program_source_map = @@ -299,6 +300,10 @@ const std::map GCKernelLibrary::_program_source_map = "scale.cs", #include "./cs_shaders/scale.csembed" }, + { + "arithmetic_add.cs", +#include "./cs_shaders/arithmetic_add.csembed" + }, #endif /* EMBEDDED_KERNELS */ }; diff --git a/src/core/GLES_COMPUTE/cs_shaders/arithmetic_add.cs b/src/core/GLES_COMPUTE/cs_shaders/arithmetic_add.cs new file mode 100755 index 0000000000..0ff43605ba --- /dev/null +++ b/src/core/GLES_COMPUTE/cs_shaders/arithmetic_add.cs @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2016, 2017 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. + */ + +layout(local_size_x = LOCAL_SIZE_X, local_size_y = LOCAL_SIZE_Y, local_size_z = LOCAL_SIZE_Z) in; + +#include "helpers_cs.h" + +precision mediump float; +#define ADD(x, y) (x) + (y) + +/** This function add two images. + * + * @param[in] src1_ptr Pointer to the first source image. Supported data types: F16 + * @param[in] src1_attrs The attributes of the first source image + * @param[in] src2_ptr Pointer to the second source image. Supported data types: Same as @p src1_ptr + * @param[in] src2_attrs The attributes of the second source image + * @param[out] dst_ptr Pointer to the destination image. Supported data types: Same as @p src1_ptr + * @param[in] dst_attrs The attributes of the destination image + */ +SHADER_PARAMS_DECLARATION +{ + ImageAttributes src1_attrs; + ImageAttributes src2_attrs; + ImageAttributes dst_attrs; +}; + +TENSOR_DECLARATION(1, src1Buffer, uvec4, src1_ptr, src1_shift, 4, readonly); +TENSOR_DECLARATION(2, src2Buffer, uvec4, src2_ptr, src2_shift, 4, readonly); +TENSOR_DECLARATION(3, dstBuffer, uvec4, dst_ptr, dst_shift, 4, writeonly); + +void main(void) +{ + ImageIterator src1_iter = CONVERT_TO_IMAGE_ITERATOR(src1_attrs, src1_shift); + ImageIterator src2_iter = CONVERT_TO_IMAGE_ITERATOR(src2_attrs, src2_shift); + ImageIterator dst_iter = CONVERT_TO_IMAGE_ITERATOR(dst_attrs, dst_shift); + + vec4 tmp1[2] = LOAD_UNPACK8_CURRENT_ITEM_HALF(src1_ptr, src1_iter); + vec4 tmp2[2] = LOAD_UNPACK8_CURRENT_ITEM_HALF(src2_ptr, src2_iter); + vec4 addition[2]; + addition[0] = ADD(tmp1[0], tmp2[0]); + addition[1] = ADD(tmp1[1], tmp2[1]); + + STORE_PACK8_CURRENT_ITEM_HALF(dst_ptr, dst_iter, addition); +} \ No newline at end of file diff --git a/src/core/GLES_COMPUTE/kernels/GCArithmeticAdditionKernel.cpp b/src/core/GLES_COMPUTE/kernels/GCArithmeticAdditionKernel.cpp new file mode 100644 index 0000000000..caec324de2 --- /dev/null +++ b/src/core/GLES_COMPUTE/kernels/GCArithmeticAdditionKernel.cpp @@ -0,0 +1,152 @@ +/* + * Copyright (c) 2016, 2017 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. + */ +#include "arm_compute/core/GLES_COMPUTE/kernels/GCArithmeticAdditionKernel.h" + +#include "arm_compute/core/Error.h" +#include "arm_compute/core/GLES_COMPUTE/GCHelpers.h" +#include "arm_compute/core/GLES_COMPUTE/GCKernelLibrary.h" +#include "arm_compute/core/GLES_COMPUTE/IGCTensor.h" +#include "arm_compute/core/GLES_COMPUTE/OpenGLES.h" +#include "arm_compute/core/Helpers.h" +#include "arm_compute/core/IAccessWindow.h" +#include "arm_compute/core/TensorInfo.h" +#include "arm_compute/core/Utils.h" +#include "arm_compute/core/Validate.h" +#include "arm_compute/core/Window.h" + +#include +#include +#include + +using namespace arm_compute; + +namespace +{ +Status validate_arguments(const ITensorInfo *input1, const ITensorInfo *input2, const ITensorInfo *output, ConvertPolicy policy) +{ + ARM_COMPUTE_UNUSED(policy); + ARM_COMPUTE_ERROR_ON_NULLPTR(input1, input2, output); + ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input1, 1, DataType::F16); + ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input2, 1, DataType::F16); + ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_SHAPES(input1, input2); + + // Validate in case of configured output + if((output != nullptr) && (output->total_size() != 0)) + { + ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(output, 1, DataType::F16); + ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_SHAPES(input1, output); + } + + return Status{}; +} + +std::pair validate_and_configure_window(ITensorInfo *input1, ITensorInfo *input2, ITensorInfo *output) +{ + constexpr unsigned int num_elems_processed_per_iteration = 8; + + Window win = calculate_max_window(*input1, Steps(num_elems_processed_per_iteration)); + + AccessWindowHorizontal input1_access(input1, 0, num_elems_processed_per_iteration); + AccessWindowHorizontal input2_access(input2, 0, num_elems_processed_per_iteration); + AccessWindowHorizontal output_access(output, 0, num_elems_processed_per_iteration); + + bool window_changed = update_window_and_padding(win, input1_access, input2_access, output_access); + + ValidRegion valid_region = intersect_valid_regions(input1->valid_region(), + input2->valid_region()); + + output_access.set_valid_region(win, valid_region); + + Status err = (window_changed) ? ARM_COMPUTE_CREATE_ERROR(ErrorCode::RUNTIME_ERROR, "Insufficient Padding!") : Status{}; + return std::make_pair(err, win); +} +} // namespace + +GCArithmeticAdditionKernel::GCArithmeticAdditionKernel() + : _input1(nullptr), _input2(nullptr), _output(nullptr) +{ +} + +void GCArithmeticAdditionKernel::configure(const IGCTensor *input1, const IGCTensor *input2, IGCTensor *output, ConvertPolicy policy) +{ + ARM_COMPUTE_UNUSED(policy); + ARM_COMPUTE_ERROR_ON_NULLPTR(input1, input2, output); + + // Auto initialize output if not initialized + { + set_shape_if_empty(*output->info(), input1->info()->tensor_shape()); + set_format_if_unknown(*output->info(), Format::F16); + } + + ARM_COMPUTE_ERROR_THROW_ON(validate_arguments(input1->info(), input2->info(), output->info(), policy)); + + _input1 = input1; + _input2 = input2; + _output = output; + + // Set kernel build options + std::set build_opts; + build_opts.emplace("#define LOCAL_SIZE_X " + support::cpp11::to_string(1)); + build_opts.emplace("#define LOCAL_SIZE_Y " + support::cpp11::to_string(1)); + build_opts.emplace("#define LOCAL_SIZE_Z " + support::cpp11::to_string(1)); + + // Create kernel + _kernel = static_cast(GCKernelLibrary::get().create_kernel("arithmetic_add", build_opts)); + + // Configure kernel window + auto win_config = validate_and_configure_window(input1->info(), input2->info(), output->info()); + ARM_COMPUTE_ERROR_THROW_ON(win_config.first); + IGCKernel::configure(win_config.second); +} + +Status GCArithmeticAdditionKernel::validate(const ITensorInfo *input1, const ITensorInfo *input2, const ITensorInfo *output, ConvertPolicy policy) +{ + ARM_COMPUTE_RETURN_ON_ERROR(validate_arguments(input1, input2, output, policy)); + ARM_COMPUTE_RETURN_ON_ERROR(validate_and_configure_window(input1->clone().get(), input2->clone().get(), output->clone().get()).first); + + return Status{}; +} + +void GCArithmeticAdditionKernel::run(const Window &window) +{ + ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this); + ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(IGCKernel::window(), window); + + _kernel.use(); + + Window slice = window.first_slice_window_2D(); + do + { + unsigned int idx = 0; + unsigned int binding = 1; // SSBO binding starts from 1. + add_2D_tensor_argument(idx, _input1, binding++, slice); + add_2D_tensor_argument(idx, _input2, binding++, slice); + add_2D_tensor_argument(idx, _output, binding++, slice); + + _kernel.update_shader_params(); + + enqueue(*this, slice); + } + while(window.slide_window_slice_2D(slice)); +} diff --git a/src/runtime/GLES_COMPUTE/functions/GCArithmeticAddition.cpp b/src/runtime/GLES_COMPUTE/functions/GCArithmeticAddition.cpp new file mode 100755 index 0000000000..b99716b6cc --- /dev/null +++ b/src/runtime/GLES_COMPUTE/functions/GCArithmeticAddition.cpp @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2016, 2017 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. + */ +#include "arm_compute/runtime/GLES_COMPUTE/functions/GCArithmeticAddition.h" + +#include "arm_compute/core/GLES_COMPUTE/kernels/GCArithmeticAdditionKernel.h" +#include "support/ToolchainSupport.h" + +#include + +using namespace arm_compute; + +void GCArithmeticAddition::configure(const IGCTensor *input1, const IGCTensor *input2, IGCTensor *output, ConvertPolicy policy) +{ + auto k = arm_compute::support::cpp14::make_unique(); + k->configure(input1, input2, output, policy); + _kernel = std::move(k); +} + +Status GCArithmeticAddition::validate(const ITensorInfo *input1, const ITensorInfo *input2, const ITensorInfo *output, ConvertPolicy policy) +{ + return GCArithmeticAdditionKernel::validate(input1, input2, output, policy); +} diff --git a/tests/validation/GLES_COMPUTE/ArithmeticAddition.cpp b/tests/validation/GLES_COMPUTE/ArithmeticAddition.cpp new file mode 100755 index 0000000000..b16503e079 --- /dev/null +++ b/tests/validation/GLES_COMPUTE/ArithmeticAddition.cpp @@ -0,0 +1,72 @@ +/* + * Copyright (c) 2017 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. + */ +#include "arm_compute/core/Types.h" +#include "arm_compute/runtime/GLES_COMPUTE/GCTensor.h" +#include "arm_compute/runtime/GLES_COMPUTE/GCTensorAllocator.h" +#include "arm_compute/runtime/GLES_COMPUTE/functions/GCArithmeticAddition.h" +#include "tests/GLES_COMPUTE/GCAccessor.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/ArithmeticAdditionFixture.h" + +namespace arm_compute +{ +namespace test +{ +namespace validation +{ +namespace +{ +/** Input data sets **/ +const auto ArithmeticAdditionFP16Dataset = combine(combine(framework::dataset::make("DataType", DataType::F16), framework::dataset::make("DataType", DataType::F16)), + framework::dataset::make("DataType", DataType::F16)); + +} // namespace + +TEST_SUITE(GC) +TEST_SUITE(ArithmeticAddition) +template +using GCArithmeticAdditionFixture = ArithmeticAdditionValidationFixture; + +TEST_SUITE(Float) +TEST_SUITE(FP16) +FIXTURE_DATA_TEST_CASE(RunSmall, GCArithmeticAdditionFixture, framework::DatasetMode::ALL, combine(combine(datasets::SmallShapes(), ArithmeticAdditionFP16Dataset), + framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP }))) +{ + // Validate output + validate(GCAccessor(_target), _reference); +} +TEST_SUITE_END() +TEST_SUITE_END() + +TEST_SUITE_END() +TEST_SUITE_END() +} // namespace validation +} // namespace test +} // namespace arm_compute -- cgit v1.2.1