From b4af2c6738614850aaca3754904f0e8e3b17f0b2 Mon Sep 17 00:00:00 2001 From: Georgios Pinitas Date: Mon, 10 Dec 2018 18:45:35 +0000 Subject: COMPMID-1710: Fixes in StrideSlice calculations. Change-Id: I66eb922f1ff15142de278bf4439a61c979f98ba7 Reviewed-on: https://review.mlplatform.org/382 Reviewed-by: Matthew Bentham Tested-by: Arm Jenkins Reviewed-by: Pablo Marquez --- arm_compute/core/utils/helpers/bit_ops.h | 52 +++++++++++++ arm_compute/core/utils/helpers/tensor_transform.h | 92 ++++++++++++++--------- arm_compute/core/utils/misc/ShapeCalculator.h | 15 ++-- 3 files changed, 115 insertions(+), 44 deletions(-) create mode 100644 arm_compute/core/utils/helpers/bit_ops.h (limited to 'arm_compute/core/utils') diff --git a/arm_compute/core/utils/helpers/bit_ops.h b/arm_compute/core/utils/helpers/bit_ops.h new file mode 100644 index 0000000000..fd27014a46 --- /dev/null +++ b/arm_compute/core/utils/helpers/bit_ops.h @@ -0,0 +1,52 @@ +/* + * 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_UTILS_HELPERS_BIT_OPS_H__ +#define __ARM_COMPUTE_UTILS_HELPERS_BIT_OPS_H__ + +#include "arm_compute/core/utils/misc/Requires.h" + +#include + +namespace arm_compute +{ +namespace helpers +{ +namespace bit_ops +{ +/** Checks if the idx-th bit is set in an integral type + * + * @param[in] v Integral input + * @param[in] idx Index of the bit to check + * + * @return True if the idx-th bit is set else false + */ +template ::value)> +bool is_bit_set(T v, unsigned int idx) +{ + return (v & 1 << idx) != 0; +} +} // namespace bit_ops +} // namespace helpers +} // namespace arm_compute +#endif /* __ARM_COMPUTE_UTILS_HELPERS_BIT_OPS_H__ */ diff --git a/arm_compute/core/utils/helpers/tensor_transform.h b/arm_compute/core/utils/helpers/tensor_transform.h index 966c1f1fdf..aa359ad119 100644 --- a/arm_compute/core/utils/helpers/tensor_transform.h +++ b/arm_compute/core/utils/helpers/tensor_transform.h @@ -32,45 +32,33 @@ namespace helpers { namespace tensor_transform { -/** Returns the absolute ends coordinates of slice +/** Computes stride of a given index * - * @param[in] input_shape Input tensor shape - * @param[in] ends End coordinates + * @param[in] index Index of tensor to calculate absolute start position + * @param[in] strides Slice strides * - * @return Absolute end coordinate + * @return Stride at a given index */ -Coordinates slice_absolute_end_coords(TensorShape input_shape, Coordinates ends); +int calculate_stride_on_index(int index, Coordinates strides); -/** Computes output shape of slice - * - * @warning Ends must be non-negative - * - * @param[in] input_shape Input tensor shape - * @param[in] starts Start coordinates - * @param[in] ends_abs Absolute end coordinates - * - * @return The output tensor shape - */ -TensorShape compute_slice_output_shape(TensorShape input_shape, Coordinates starts, Coordinates ends_abs); - -/** Returns the absolute start coordinates of strided slice +/** Computes absolute start position of a given index for a strided slice operation * * @param[in] input_shape Input tensor shape + * @param[in] index Index of tensor to calculate absolute start position * @param[in] starts Start coordinates * @param[in] strides Slice strides * @param[in] begin_mask (Optional) If the ith bit of begin_mask is set, starts[i] is ignored and * the fullest possible range in that dimension is used instead. * - * @return Absolute start coordinates + * @return Absolute start position of a given index */ -Coordinates strided_slice_absolute_start_coords(TensorShape input_shape, Coordinates starts, Coordinates strides, int32_t begin_mask = 0); +int calculate_start_on_index(TensorShape input_shape, int index, Coordinates starts, Coordinates strides, int32_t begin_mask); -/** Returns the absolute ends coordinates of strided slice - * - * @warning Starts must be non-negative +/** Returns the absolute end position of a given index for a strided slice operation * * @param[in] input_shape Input tensor shape - * @param[in] starts_abs Absolute start coordinates + * @param[in] index Index of tensor to calculate absolute start position + * @param[in] start_on_index Absolute start coordinate for given index * @param[in] ends End coordinates * @param[in] strides Slice strides * @param[in] end_mask (Optional) If the ith bit of end_mask is set, end[i] is ignored and @@ -78,32 +66,62 @@ Coordinates strided_slice_absolute_start_coords(TensorShape input_shape, Coordin * @param[in] shrink_axis_mask (Optional) If the ith bit of shrink_axis_mask is set, it implies that the ith specification shrinks the dimensionality by 1. * A slice of size 1 starting from starts[i] in the dimension must be preserved. * - * @return Absolute end coordinates + * @return Absolute end position of a given index */ -Coordinates strided_slice_absolute_end_coords(TensorShape input_shape, Coordinates starts_abs, Coordinates ends, Coordinates strides, - int32_t end_mask = 0, int32_t shrink_axis_mask = 0); -/** Returns the final strides of strided slice +int calculate_end_on_index(TensorShape input_shape, int index, int start_on_index, Coordinates ends, Coordinates strides, + int32_t end_mask = 0, int32_t shrink_axis_mask = 0); + +/** Calculate start, end and stride coordinates for a strided slice * - * @param[in] input_shape Input tensor shape - * @param[in] strides Slice strides + * @param[in] input_shape Input tensor shape + * @param[in] starts Start coordinates + * @param[in] ends End coordinates + * @param[in] strides Slice strides + * @param[in] begin_mask (Optional) If the ith bit of begin_mask is set, starts[i] is ignored and + * the fullest possible range in that dimension is used instead. + * @param[in] end_mask (Optional) If the ith bit of end_mask is set, end[i] is ignored and + * the fullest possible range in that dimension is used instead. + * @param[in] shrink_axis_mask (Optional) If the ith bit of shrink_axis_mask is set, it implies that the ith specification shrinks the dimensionality by 1. + * A slice of size 1 starting from starts[i] in the dimension must be preserved. * - * @return The final strides need by strided slice + * @return A tuple with */ -Coordinates strided_slice_strides(TensorShape input_shape, Coordinates strides); +std::tuple calculate_strided_slice_coords(TensorShape input_shape, + Coordinates starts, Coordinates ends, Coordinates strides, + int32_t begin_mask = 0, int32_t end_mask = 0, int32_t shrink_axis_mask = 0); /** Computes output shape of strided slice * * @warning Starts and ends must be non-negative * @warning Starts, ends and final strides should have the same dimensions as the input shape * - * @param[in] input_shape Input tensor shape - * @param[in] starts_abs Absolute start coordinates - * @param[in] ends_abs Absolute end coordinates - * @param[in] final_strides Slice strides + * @param[in] input_shape Input tensor shape + * @param[in] starts Absolute start coordinates + * @param[in] ends Absolute end coordinates + * @param[in] strides Slice strides + * @param[in] begin_mask (Optional) If the ith bit of begin_mask is set, starts[i] is ignored and + * the fullest possible range in that dimension is used instead. + * @param[in] end_mask (Optional) If the ith bit of end_mask is set, end[i] is ignored and + * the fullest possible range in that dimension is used instead. + * @param[in] shrink_axis_mask (Optional) If the ith bit of shrink_axis_mask is set, it implies that the ith specification shrinks the dimensionality by 1. + * A slice of size 1 starting from starts[i] in the dimension must be preserved. + * @param[in] return_unshrinked (Optional) Returns un-shrinked shape * * @return The output tensor shape */ -TensorShape compute_strided_slice_output_shape(TensorShape input_shape, Coordinates starts_abs, Coordinates ends_abs, Coordinates final_strides); +TensorShape compute_strided_slice_output_shape(TensorShape input_shape, Coordinates starts, Coordinates ends, Coordinates strides, + int32_t begin_mask = 0, int32_t end_mask = 0, int32_t shrink_axis_mask = 0, + bool return_unshrinked = false); + +/** Constructs end mask in case we want to perform a slice operation using the strided slice interface + * + * @note Ends are inclusive in slice operations that is why construction an end mask is needed + * + * @param[in] ends End coordinates + * + * @return End mask + */ +int32_t construct_slice_end_mask(Coordinates ends); } // namespace tensor_tranform } // namespace helpers } // namespace arm_compute diff --git a/arm_compute/core/utils/misc/ShapeCalculator.h b/arm_compute/core/utils/misc/ShapeCalculator.h index f41d00f54d..adf5309ea5 100644 --- a/arm_compute/core/utils/misc/ShapeCalculator.h +++ b/arm_compute/core/utils/misc/ShapeCalculator.h @@ -668,15 +668,16 @@ inline TensorShape compute_strided_slice_shape(const ITensorInfo &input, int32_t begin_mask, int32_t end_mask, int32_t shrink_axis_mask) { using namespace arm_compute::helpers::tensor_transform; + return compute_strided_slice_output_shape(input.tensor_shape(), starts, ends, strides, begin_mask, end_mask, shrink_axis_mask); +} - const TensorShape &input_shape = input.tensor_shape(); - - // Get actual start, end coordinates and strides - const Coordinates final_strides = strided_slice_strides(input_shape, strides); - const Coordinates starts_abs = strided_slice_absolute_start_coords(input_shape, starts, final_strides, begin_mask); - const Coordinates ends_abs = strided_slice_absolute_end_coords(input_shape, starts_abs, ends, final_strides, end_mask, shrink_axis_mask); +inline TensorShape compute_slice_shape(const TensorShape &input_shape, const Coordinates &starts, const Coordinates &ends) +{ + using namespace arm_compute::helpers::tensor_transform; - return compute_strided_slice_output_shape(input_shape, starts_abs, ends_abs, final_strides); + return compute_strided_slice_output_shape(input_shape, + starts, ends, BiStrides(), + 0, construct_slice_end_mask(ends), 0); } inline TensorShape compute_batch_to_space_shape(const ITensorInfo *input, const int block_x, const int block_y) -- cgit v1.2.1