diff options
author | Anthony Barbier <anthony.barbier@arm.com> | 2017-09-04 18:44:23 +0100 |
---|---|---|
committer | Anthony Barbier <anthony.barbier@arm.com> | 2018-09-17 13:03:09 +0100 |
commit | 6ff3b19ee6120edf015fad8caab2991faa3070af (patch) | |
tree | a7a6dcd16dfd56d79fa1b56a313caeebcc939b68 /src/core/AccessWindowStatic.cpp | |
download | ComputeLibrary-6ff3b19ee6120edf015fad8caab2991faa3070af.tar.gz |
COMPMID-344 Updated doxygen
Change-Id: I32f7b84daa560e460b77216add529c8fa8b327ae
Diffstat (limited to 'src/core/AccessWindowStatic.cpp')
-rw-r--r-- | src/core/AccessWindowStatic.cpp | 202 |
1 files changed, 202 insertions, 0 deletions
diff --git a/src/core/AccessWindowStatic.cpp b/src/core/AccessWindowStatic.cpp new file mode 100644 index 0000000000..8b6419c485 --- /dev/null +++ b/src/core/AccessWindowStatic.cpp @@ -0,0 +1,202 @@ +/* + * 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/AccessWindowStatic.h" + +#include "arm_compute/core/Helpers.h" +#include "arm_compute/core/ITensorInfo.h" +#include "arm_compute/core/Window.h" + +using namespace arm_compute; + +AccessWindowStatic::AccessWindowStatic(ITensorInfo *info, int start_x, int start_y, int end_x, int end_y) + : _info(info), _start_x(start_x), _start_y(start_y), _end_x(end_x), _end_y(end_y) +{ +} + +ValidRegion AccessWindowStatic::compute_valid_region(const Window &window, ValidRegion input_valid_region, bool border_undefined, BorderSize border_size) const +{ + ARM_COMPUTE_UNUSED(border_undefined); + ARM_COMPUTE_UNUSED(border_size); + + return compute_valid_region(window, input_valid_region); +} + +ValidRegion AccessWindowStatic::compute_valid_region(const Window &window, ValidRegion input_valid_region) const +{ + if(_info == nullptr) + { + return input_valid_region; + } + + Coordinates &anchor = input_valid_region.anchor; + TensorShape &shape = input_valid_region.shape; + + // Start of the valid region is equal to the start of the static access but + // never outside of the tensor. + anchor.set(0, std::max<int>(0, _start_x)); + if(_info->num_dimensions() > 1) + { + anchor.set(1, std::max<int>(0, _start_y)); + } + + // End of the valid region is equal to the end of the static access but + // never outside of the tensor. + shape.set(0, std::min<int>(_end_x, _info->tensor_shape()[0])); + if(_info->num_dimensions() > 1) + { + shape.set(1, std::min<int>(_end_y, _info->tensor_shape()[1])); + } + + // For higher dimension use the intersection of the window size and the + // valid region of the input + for(size_t d = 2; d < _info->num_dimensions(); ++d) + { + anchor.set(d, std::max(window[d].start(), input_valid_region.anchor[d])); + shape.set(d, std::min<int>(window[d].end(), input_valid_region.shape[d]) - anchor[d]); + } + + return input_valid_region; +} + +void AccessWindowStatic::set_valid_region(const Window &window, const ValidRegion &input_valid_region) +{ + if(_info != nullptr) + { + _info->set_valid_region(compute_valid_region(window, input_valid_region)); + } +} + +bool AccessWindowStatic::update_window_if_needed(Window &window) const +{ + // Only update the window size if we can't use padding + if(_info == nullptr || _info->is_resizable()) + { + return false; + } + + const TensorShape &shape = _info->tensor_shape(); + const Strides &strides = _info->strides_in_bytes(); + const size_t offset_first_element = _info->offset_first_element_in_bytes(); + + bool window_modified = false; + + int front_pad_y = 0; + + // Adjust window start for Y dimension + if(_start_y < 0) + { + // Calculate rows available above the tensor + const int front_pad_y_available = -static_cast<int>(offset_first_element / strides[1]); + + if(_start_y < front_pad_y_available) + { + // Not enough padding available, need to shrink the window + const int start = adjust_up(_start_y, front_pad_y_available, window.y().step()); + + window.set(1, Window::Dimension(start, window.y().end(), window.y().step())); + window_modified = true; + } + + // Update front padding with reconstructed value + front_pad_y = std::max(0, -window.y().start()); + } + + // Adjust window end for Y dimension + if(_end_y > static_cast<int>(shape[1])) + { + const int stride_z = _info->num_dimensions() > 2 ? strides[2] : _info->total_size(); + + // Calculate rows available below the tensor + const int tail_pad_y_available = (stride_z / strides[1]) - shape[1] - front_pad_y; + + if(static_cast<int>(shape[1]) + tail_pad_y_available < _end_y) + { + // Not enough padding available, need to shrink the window + const int end = adjust_down(_end_y, shape[1] + tail_pad_y_available, window.y().step()) + window.y().step(); + window.set(1, Window::Dimension(window.y().start(), end, window.y().step())); + window_modified = true; + } + } + + int front_pad_x = 0; + + const int stride_y = _info->num_dimensions() > 1 ? strides[1] : _info->total_size(); + + // Adjust window start for X dimension + if(_start_x < 0) + { + const int front_pad_x_available = -std::min<int>(static_cast<int>(offset_first_element) - front_pad_y * strides[1], stride_y - shape[0] * strides[0]) / static_cast<int>(strides[0]); + + if(_start_x < front_pad_x_available) + { + // Not enough padding available, need to shrink the window + const int start = adjust_up(_start_x, front_pad_x_available, window.x().step()); + window.set(0, Window::Dimension(start, window.x().end(), window.x().step())); + window_modified = true; + } + + // Update front padding with reconstructed value + front_pad_x = std::max(0, -window.x().start()); + } + + // Adjust window end for X dimension + if(_end_x > static_cast<int>(shape[0])) + { + const int tail_pad_x_available = (stride_y / strides[0]) - shape[0] - front_pad_x; + + if(static_cast<int>(shape[0]) + tail_pad_x_available < _end_x) + { + // Not enough padding available, need to shrink the window + const int end = adjust_down(_end_x, shape[0] + tail_pad_x_available, window.x().step()) + window.x().step(); + window.set(0, Window::Dimension(window.x().start(), end, window.x().step())); + window_modified = true; + } + } + + window.validate(); + + return window_modified; +} + +bool AccessWindowStatic::update_padding_if_needed(const Window &window) const +{ + ARM_COMPUTE_UNUSED(window); + + // Only update the padding if the tensor allows it + if(_info == nullptr || !_info->is_resizable()) + { + return false; + } + + const TensorShape &shape = _info->tensor_shape(); + + PaddingSize padding; + padding.left = std::max(0, -_start_x); + padding.right = std::max<int>(0, _end_x - shape[0]); + padding.top = shape.num_dimensions() == 1 ? 0 : std::max(0, -_start_y); + padding.bottom = shape.num_dimensions() == 1 ? 0 : std::max<int>(0, _end_y - shape[1]); + + // Update strides in tensor info + return _info->extend_padding(padding); +} |