From 6259e5f9204abf31b811b1d002f68ce6504197bd Mon Sep 17 00:00:00 2001 From: Michele Di Giorgio Date: Wed, 17 Jan 2018 17:29:33 +0000 Subject: COMPMID-787: Add CL support for broadcast multiply Change-Id: I71f67789648ef05ccdedce77c7427bc0127b3a69 Reviewed-on: https://eu-gerrit-1.euhpc.arm.com/116741 Tested-by: Jenkins Reviewed-by: Georgios Pinitas Reviewed-by: Anthony Barbier --- .../reference/PixelWiseMultiplication.cpp | 119 +++++++++++++++------ 1 file changed, 89 insertions(+), 30 deletions(-) (limited to 'tests/validation/reference/PixelWiseMultiplication.cpp') diff --git a/tests/validation/reference/PixelWiseMultiplication.cpp b/tests/validation/reference/PixelWiseMultiplication.cpp index b3647fc9ce..546a886ac9 100644 --- a/tests/validation/reference/PixelWiseMultiplication.cpp +++ b/tests/validation/reference/PixelWiseMultiplication.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017 ARM Limited. + * Copyright (c) 2017-2018 ARM Limited. * * SPDX-License-Identifier: MIT * @@ -41,46 +41,105 @@ struct is_floating_point { }; +namespace +{ +/** Compute the result of `src1 * src2 * scale`. The result type always matches the type of @p src2. + * + * @param[in] src1 An input value. Data types supported: U8/QS8/QS16/S16/F16/F32. + * @param[in] src2 An input value. Data types supported: same as @p src1. + * @param[in] scale Scale to apply after multiplication. + * Scale must be positive and its value must be either 1/255 or 1/2^n where n is between 0 and 15. For QS8 and QS16 scale must be 1. + * @param[in] convert_policy Overflow policy. Supported overflow policies: Wrap, Saturate + * @param[in] rounding_policy Rounding policy. Supported rounding modes: to zero, to nearest even. + */ template -SimpleTensor pixel_wise_multiplication(const SimpleTensor &src1, const SimpleTensor &src2, float scale, ConvertPolicy convert_policy, RoundingPolicy rounding_policy) +T2 mul(const T1 src1, const T2 src2, float scale, ConvertPolicy convert_policy, RoundingPolicy rounding_policy) { - SimpleTensor dst(src2.shape(), src2.data_type()); + using intermediate_type = typename common_promoted_signed_type::intermediate_type; - if(scale < 0) - { - ARM_COMPUTE_ERROR("Scale of pixel-wise multiplication must be non-negative"); - } + const double val = static_cast(src1) * static_cast(src2) * static_cast(scale); - using intermediate_type = typename common_promoted_signed_type::intermediate_type; + if(is_floating_point::value) + { + const auto result = static_cast(val); - for(int i = 0; i < src1.num_elements(); ++i) + return result; + } + else { - double val = static_cast(src1[i]) * static_cast(src2[i]) * static_cast(scale); - if(is_floating_point::value) + double rounded_val = 0; + switch(rounding_policy) { - dst[i] = val; + case(RoundingPolicy::TO_ZERO): + rounded_val = support::cpp11::trunc(val); + break; + case(RoundingPolicy::TO_NEAREST_UP): + rounded_val = round_half_up(val); + break; + case(RoundingPolicy::TO_NEAREST_EVEN): + rounded_val = round_half_even(val); + break; + default: + ARM_COMPUTE_ERROR("Unsupported rounding policy"); } - else + + const auto result = static_cast((convert_policy == ConvertPolicy::SATURATE) ? saturate_cast(rounded_val) : rounded_val); + + return result; + } +} + +template +struct BroadcastUnroll +{ + template + static void unroll(const SimpleTensor &src1, const SimpleTensor &src2, SimpleTensor &dst, + float scale, ConvertPolicy convert_policy, RoundingPolicy rounding_policy, + Coordinates &id_src1, Coordinates &id_src2, Coordinates &id_dst) + { + const bool src1_is_broadcast = (src1.shape()[dim - 1] != dst.shape()[dim - 1]); + const bool src2_is_broadcast = (src2.shape()[dim - 1] != dst.shape()[dim - 1]); + + id_src1.set(dim - 1, 0); + id_src2.set(dim - 1, 0); + id_dst.set(dim - 1, 0); + + for(size_t i = 0; i < dst.shape()[dim - 1]; ++i, ++id_dst[dim - 1]) { - double rounded_val = 0; - switch(rounding_policy) - { - case(RoundingPolicy::TO_ZERO): - rounded_val = support::cpp11::trunc(val); - break; - case(RoundingPolicy::TO_NEAREST_UP): - rounded_val = round_half_up(val); - break; - case(RoundingPolicy::TO_NEAREST_EVEN): - rounded_val = round_half_even(val); - break; - default: - ARM_COMPUTE_ERROR("Unsupported rounding policy"); - } - - dst[i] = (convert_policy == ConvertPolicy::SATURATE) ? saturate_cast(rounded_val) : static_cast(rounded_val); + BroadcastUnroll < dim - 1 >::unroll(src1, src2, dst, scale, convert_policy, rounding_policy, id_src1, id_src2, id_dst); + + id_src1[dim - 1] += !src1_is_broadcast; + id_src2[dim - 1] += !src2_is_broadcast; } } +}; + +template <> +struct BroadcastUnroll<0> +{ + template + static void unroll(const SimpleTensor &src1, const SimpleTensor &src2, SimpleTensor &dst, + float scale, ConvertPolicy convert_policy, RoundingPolicy rounding_policy, + Coordinates &id_src1, Coordinates &id_src2, Coordinates &id_dst) + { + dst[coord2index(dst.shape(), id_dst)] = mul(src1[coord2index(src1.shape(), id_src1)], src2[coord2index(src2.shape(), id_src2)], scale, convert_policy, rounding_policy); + } +}; +} // namespace + +template +SimpleTensor pixel_wise_multiplication(const SimpleTensor &src1, const SimpleTensor &src2, float scale, ConvertPolicy convert_policy, RoundingPolicy rounding_policy) +{ + SimpleTensor dst(TensorShape::broadcast_shape(src1.shape(), src2.shape()), src2.data_type()); + + if(scale < 0) + { + ARM_COMPUTE_ERROR("Scale of pixel-wise multiplication must be non-negative"); + } + + Coordinates id_src1, id_src2, id_dst; + + BroadcastUnroll::unroll(src1, src2, dst, scale, convert_policy, rounding_policy, id_src1, id_src2, id_dst); return dst; } -- cgit v1.2.1