253 lines
9.5 KiB
C++
253 lines
9.5 KiB
C++
/*
|
|
* Copyright (c) 2016-2020 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_HELPERS_H
|
|
#define ARM_COMPUTE_HELPERS_H
|
|
|
|
#include "arm_compute/core/Error.h"
|
|
#include "arm_compute/core/IAccessWindow.h"
|
|
#include "arm_compute/core/ITensor.h"
|
|
#include "arm_compute/core/Types.h"
|
|
#include "arm_compute/core/Validate.h"
|
|
#include "arm_compute/core/Window.h"
|
|
|
|
#include <array>
|
|
#include <cstddef>
|
|
#include <cstdint>
|
|
#include <tuple>
|
|
|
|
namespace arm_compute
|
|
{
|
|
class IKernel;
|
|
class ITensor;
|
|
class ITensorInfo;
|
|
|
|
/** Iterator updated by @ref execute_window_loop for each window element */
|
|
class Iterator
|
|
{
|
|
public:
|
|
/** Default constructor to create an empty iterator */
|
|
constexpr Iterator();
|
|
/** Create a container iterator for the metadata and allocation contained in the ITensor
|
|
*
|
|
* @param[in] tensor The tensor to associate to the iterator.
|
|
* @param[in] window The window which will be used to iterate over the tensor.
|
|
*/
|
|
Iterator(const ITensor *tensor, const Window &window);
|
|
|
|
/** Increment the iterator along the specified dimension of the step value associated to the dimension.
|
|
*
|
|
* @warning It is the caller's responsibility to call increment(dimension+1) when reaching the end of a dimension, the iterator will not check for overflow.
|
|
*
|
|
* @note When incrementing a dimension 'n' the coordinates of all the dimensions in the range (0,n-1) are reset. For example if you iterate over a 2D image, everytime you change row (dimension 1), the iterator for the width (dimension 0) is reset to its start.
|
|
*
|
|
* @param[in] dimension Dimension to increment
|
|
*/
|
|
void increment(size_t dimension);
|
|
|
|
/** Return the offset in bytes from the first element to the current position of the iterator
|
|
*
|
|
* @return The current position of the iterator in bytes relative to the first element.
|
|
*/
|
|
constexpr size_t offset() const;
|
|
|
|
/** Return a pointer to the current pixel.
|
|
*
|
|
* @warning Only works if the iterator was created with an ITensor.
|
|
*
|
|
* @return equivalent to buffer() + offset()
|
|
*/
|
|
constexpr uint8_t *ptr() const;
|
|
|
|
/** Move the iterator back to the beginning of the specified dimension.
|
|
*
|
|
* @param[in] dimension Dimension to reset
|
|
*/
|
|
void reset(size_t dimension);
|
|
|
|
private:
|
|
uint8_t *_ptr;
|
|
|
|
class Dimension
|
|
{
|
|
public:
|
|
constexpr Dimension()
|
|
: _dim_start(0), _stride(0)
|
|
{
|
|
}
|
|
|
|
size_t _dim_start;
|
|
size_t _stride;
|
|
};
|
|
|
|
std::array<Dimension, Coordinates::num_max_dimensions> _dims;
|
|
};
|
|
|
|
/** Iterate through the passed window, automatically adjusting the iterators and calling the lambda_functino for each element.
|
|
* It passes the x and y positions to the lambda_function for each iteration
|
|
*
|
|
* @param[in] w Window to iterate through.
|
|
* @param[in] lambda_function The function of type void(function)( const Coordinates & id ) to call at each iteration.
|
|
* Where id represents the absolute coordinates of the item to process.
|
|
* @param[in,out] iterators Tensor iterators which will be updated by this function before calling lambda_function.
|
|
*/
|
|
template <typename L, typename... Ts>
|
|
inline void execute_window_loop(const Window &w, L &&lambda_function, Ts &&... iterators);
|
|
|
|
/** Permutes given Dimensions according to a permutation vector
|
|
*
|
|
* @warning Validity of permutation is not checked
|
|
*
|
|
* @param[in, out] dimensions Dimensions to permute
|
|
* @param[in] perm Permutation vector
|
|
*/
|
|
template <typename T>
|
|
inline void permute(Dimensions<T> &dimensions, const PermutationVector &perm)
|
|
{
|
|
auto dimensions_copy = utility::make_array<Dimensions<T>::num_max_dimensions>(dimensions.begin(), dimensions.end());
|
|
for(unsigned int i = 0; i < perm.num_dimensions(); ++i)
|
|
{
|
|
T dimension_val = (perm[i] < dimensions.num_dimensions()) ? dimensions_copy[perm[i]] : 0;
|
|
dimensions.set(i, dimension_val);
|
|
}
|
|
}
|
|
|
|
/** Permutes given TensorShape according to a permutation vector
|
|
*
|
|
* @warning Validity of permutation is not checked
|
|
*
|
|
* @param[in, out] shape Shape to permute
|
|
* @param[in] perm Permutation vector
|
|
*/
|
|
inline void permute(TensorShape &shape, const PermutationVector &perm)
|
|
{
|
|
TensorShape shape_copy = shape;
|
|
for(unsigned int i = 0; i < perm.num_dimensions(); ++i)
|
|
{
|
|
size_t dimension_val = (perm[i] < shape.num_dimensions()) ? shape_copy[perm[i]] : 1;
|
|
shape.set(i, dimension_val, false); // Avoid changes in _num_dimension
|
|
}
|
|
}
|
|
|
|
/** Helper function to calculate the Valid Region for Scale.
|
|
*
|
|
* @param[in] src_info Input tensor info used to check.
|
|
* @param[in] dst_shape Shape of the output.
|
|
* @param[in] interpolate_policy Interpolation policy.
|
|
* @param[in] sampling_policy Sampling policy.
|
|
* @param[in] border_undefined True if the border is undefined.
|
|
*
|
|
* @return The corresponding valid region
|
|
*/
|
|
ValidRegion calculate_valid_region_scale(const ITensorInfo &src_info, const TensorShape &dst_shape,
|
|
InterpolationPolicy interpolate_policy, SamplingPolicy sampling_policy, bool border_undefined);
|
|
|
|
/** Convert a linear index into n-dimensional coordinates.
|
|
*
|
|
* @param[in] shape Shape of the n-dimensional tensor.
|
|
* @param[in] index Linear index specifying the i-th element.
|
|
*
|
|
* @return n-dimensional coordinates.
|
|
*/
|
|
inline Coordinates index2coords(const TensorShape &shape, int index);
|
|
|
|
/** Convert n-dimensional coordinates into a linear index.
|
|
*
|
|
* @param[in] shape Shape of the n-dimensional tensor.
|
|
* @param[in] coord N-dimensional coordinates.
|
|
*
|
|
* @return linead index
|
|
*/
|
|
inline int coords2index(const TensorShape &shape, const Coordinates &coord);
|
|
|
|
/** Get the index of the given dimension.
|
|
*
|
|
* @param[in] data_layout The data layout.
|
|
* @param[in] data_layout_dimension The dimension which this index is requested for.
|
|
*
|
|
* @return The int conversion of the requested data layout index.
|
|
*/
|
|
inline size_t get_data_layout_dimension_index(const DataLayout data_layout, const DataLayoutDimension data_layout_dimension);
|
|
|
|
/** Get the DataLayoutDimension of a given index and layout.
|
|
*
|
|
* @param[in] data_layout The data layout.
|
|
* @param[in] index The data layout index.
|
|
*
|
|
* @return The dimension which this index is requested for.
|
|
*/
|
|
inline DataLayoutDimension get_index_data_layout_dimension(const DataLayout data_layout, const size_t index);
|
|
|
|
/** Calculate the number of output tiles required by Winograd Convolution layer. This utility function can be used by the Winograd input transform
|
|
* to know the number of tiles on the x and y direction
|
|
*
|
|
* @param[in] in_dims Spatial dimensions of the input tensor of convolution layer
|
|
* @param[in] kernel_size Kernel size
|
|
* @param[in] output_tile_size Size of a single output tile
|
|
* @param[in] conv_info Convolution info (i.e. pad, stride,...)
|
|
*
|
|
* @return the number of output tiles along the x and y directions of size "output_tile_size"
|
|
*/
|
|
inline Size2D compute_winograd_convolution_tiles(const Size2D &in_dims, const Size2D &kernel_size, const Size2D &output_tile_size, const PadStrideInfo &conv_info)
|
|
{
|
|
int num_tiles_x = std::ceil((in_dims.width - (kernel_size.width - 1) + conv_info.pad_left() + conv_info.pad_right()) / static_cast<float>(output_tile_size.width));
|
|
int num_tiles_y = std::ceil((in_dims.height - (kernel_size.height - 1) + conv_info.pad_top() + conv_info.pad_bottom()) / static_cast<float>(output_tile_size.height));
|
|
|
|
// Clamp in case we provide paddings but we have 1D convolution
|
|
num_tiles_x = std::min(num_tiles_x, static_cast<int>(in_dims.width));
|
|
num_tiles_y = std::min(num_tiles_y, static_cast<int>(in_dims.height));
|
|
|
|
return Size2D(num_tiles_x, num_tiles_y);
|
|
}
|
|
|
|
/** Wrap-around a number within the range 0 <= x < m
|
|
*
|
|
* @param[in] x Input value
|
|
* @param[in] m Range
|
|
*
|
|
* @return the wrapped-around number
|
|
*/
|
|
template <typename T>
|
|
inline T wrap_around(T x, T m)
|
|
{
|
|
return x >= 0 ? x % m : (x % m + m) % m;
|
|
}
|
|
|
|
/** Convert negative coordinates to positive in the range [0, num_dims_input]
|
|
*
|
|
* @param[out] coords Array of coordinates to be converted.
|
|
* @param[in] max_value Maximum value to be used when wrapping the negative values in coords
|
|
*/
|
|
inline Coordinates &convert_negative_axis(Coordinates &coords, int max_value)
|
|
{
|
|
for(unsigned int i = 0; i < coords.num_dimensions(); ++i)
|
|
{
|
|
coords[i] = wrap_around(coords[i], max_value);
|
|
}
|
|
return coords;
|
|
}
|
|
} // namespace arm_compute
|
|
|
|
#include "arm_compute/core/Helpers.inl"
|
|
#endif /*ARM_COMPUTE_HELPERS_H */
|