src/core/IAccessWindow.cpp

   1 /*
   2  * Copyright (c) 2017-2018 ARM Limited.
   3  *
   4  * SPDX-License-Identifier: MIT
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to
   8  * deal in the Software without restriction, including without limitation the
   9  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
  10  * sell copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in all
  14  * copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  22  * SOFTWARE.
  23  */
  24 #include "arm_compute/core/IAccessWindow.h"
  25
  26 #include "arm_compute/core/Helpers.h"
  27 #include "arm_compute/core/TensorInfo.h"
  28 #include "arm_compute/core/Window.h"
  29
  30 using namespace arm_compute;
  31
  32 ValidRegion AccessWindowRectangle::compute_valid_region(const Window &window, const ValidRegion &input_valid_region) const
  33 {
  34     return compute_valid_region(window, input_valid_region, false, BorderSize(0));
  35 }
  36
  37 ValidRegion AccessWindowRectangle::compute_valid_region(const Window &window, ValidRegion input_valid_region, bool border_undefined, BorderSize border_size) const
  38 {
  39     if(_info == nullptr)
  40     {
  41         return input_valid_region;
  42     }
  43
  44     Coordinates &anchor = input_valid_region.anchor;
  45     Coordinates  old_anchor(anchor);
  46     TensorShape &shape = input_valid_region.shape;
  47
  48     if(!border_undefined)
  49     {
  50         border_size = BorderSize(0);
  51     }
  52
  53     // Start of the valid region is equal to the start of the window. But it
  54     // cannot be less than the start of the input's valid region plus the border
  55     // size required by this kernel (if undefined).
  56     // Additionally the valid region is shifted by the offset that is used by
  57     // the kernel to write back output values.
  58     anchor.set(0, std::max<int>(window.x().start() * _scale_x, anchor[0] + border_size.left) + _x);
  59     if(_info->num_dimensions() > 1)
  60     {
  61         anchor.set(1, std::max<int>(window.y().start() * _scale_y, anchor[1] + border_size.top) + _y);
  62     }
  63
  64     // End of the valid region is equal to the start of the last write of the
  65     // kernel plus the number of written elements. (This assumes that all
  66     // written elements are valid). Nevertheless the end cannot be larger than
  67     // the end of the input's valid region minus the border size.
  68     // Note: not the end points of the region are stored but its size. Thus the
  69     // old size is first converted into end points to compared against the
  70     // execution window. Afterwards the new end points are converted back into
  71     // a size of the region.
  72     shape.set(0, std::min<int>(old_anchor[0] + shape[0] - border_size.right, (window.x().end() - window.x().step()) * _scale_x + _width) - anchor[0]);
  73     if(_info->num_dimensions() > 1)
  74     {
  75         shape.set(1, std::min<int>(old_anchor[1] + shape[1] - border_size.bottom, (window.y().end() - window.y().step()) * _scale_y + _height) - anchor[1]);
  76     }
  77
  78     // For higher dimensions use the intersection of the window size and the
  79     // valid region of the input
  80     for(size_t d = 2; d < _info->num_dimensions(); ++d)
  81     {
  82         anchor.set(d, std::max(window[d].start(), input_valid_region.anchor[d]));
  83         shape.set(d, std::min<int>(window[d].end(), input_valid_region.shape[d]) - anchor[d]);
  84     }
  85
  86     return input_valid_region;
  87 }
  88
  89 void AccessWindowRectangle::set_valid_region(const Window &window, const ValidRegion &input_valid_region, bool border_undefined, const BorderSize &border_size)
  90 {
  91     if(_info != nullptr)
  92     {
  93         _info->set_valid_region(compute_valid_region(window, input_valid_region, border_undefined, border_size));
  94     }
  95 }
  96
  97 bool AccessWindowRectangle::update_window_if_needed(Window &window) const
  98 {
  99     // Only update the window size if we can't use padding
 100     if(_info == nullptr || _info->is_resizable())
 101     {
 102         return false;
 103     }
 104
 105     const TensorShape &shape                = _info->tensor_shape();
 106     const Strides     &strides              = _info->strides_in_bytes();
 107     const size_t       offset_first_element = _info->offset_first_element_in_bytes();
 108
 109     bool window_modified = false;
 110
 111     int front_pad_y = 0;
 112
 113     const int min_y = window.y().start() * _scale_y + _y;
 114     const int max_y = (window.y().end() - window.y().step()) * _scale_y + _y + _height;
 115
 116     // Adjust window start for Y dimension
 117     if(min_y < 0)
 118     {
 119         // Calculate rows available above the tensor
 120         const int front_pad_y_available = -static_cast<int>(offset_first_element / strides[1]);
 121
 122         if(min_y < front_pad_y_available)
 123         {
 124             // Not enough padding available, need to shrink the window
 125             int start = adjust_up(min_y, front_pad_y_available, window.y().step() * _scale_y) - _y;
 126             start     = std::min<int>(start / _scale_y, window.y().end());
 127
 128             window.set(1, Window::Dimension(start, window.y().end(), window.y().step()));
 129             window_modified = true;
 130         }
 131
 132         // Update front padding with reconstructed value
 133         front_pad_y = std::max(0, static_cast<int>(std::floor(-window.y().start() * _scale_y)) - _y);
 134     }
 135
 136     // Adjust window end for Y dimension
 137     if(max_y > static_cast<int>(shape[1]))
 138     {
 139         const int stride_z = _info->num_dimensions() > 2 ? strides[2] : _info->total_size();
 140
 141         // Calculate rows available below the tensor
 142         const int tail_pad_y_available = (stride_z / strides[1]) - shape[1] - front_pad_y;
 143
 144         if(static_cast<int>(shape[1]) + tail_pad_y_available < max_y)
 145         {
 146             // Not enough padding available, need to shrink the window
 147             int end = adjust_down(max_y, shape[1] + tail_pad_y_available, window.y().step() * _scale_y) + window.y().step() * _scale_y - _y - _height;
 148             end     = std::max<int>(window.y().start(), end / _scale_y);
 149
 150             window.set(1, Window::Dimension(window.y().start(), end, window.y().step()));
 151             window_modified = true;
 152         }
 153     }
 154
 155     int front_pad_x = 0;
 156
 157     const int min_x = window.x().start() * _scale_x + _x;
 158     const int max_x = (window.x().end() - window.x().step()) * _scale_x + _x + _width;
 159
 160     const int stride_y = _info->num_dimensions() > 1 ? strides[1] : _info->total_size();
 161
 162     // Adjust window start for X dimension
 163     if(min_x < 0)
 164     {
 165         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]);
 166
 167         if(min_x < front_pad_x_available)
 168         {
 169             // Not enough padding available, need to shrink the window
 170             int start = adjust_up(min_x, front_pad_x_available, window.x().step() * _scale_x) - _x;
 171             start     = std::min<int>(start / _scale_x, window.x().end());
 172
 173             window.set(0, Window::Dimension(start, window.x().end(), window.x().step()));
 174             window_modified = true;
 175         }
 176
 177         // Update front padding with reconstructed value
 178         front_pad_x = std::max(0, static_cast<int>(std::floor(-window.x().start() * _scale_x)) - _x);
 179     }
 180
 181     // Adjust window end for X dimension
 182     if(max_x > static_cast<int>(shape[0]))
 183     {
 184         const int tail_pad_x_available = (stride_y / strides[0]) - shape[0] - front_pad_x;
 185
 186         if(static_cast<int>(shape[0]) + tail_pad_x_available < max_x)
 187         {
 188             // Not enough padding available, need to shrink the window
 189             int end = adjust_down(max_x, shape[0] + tail_pad_x_available, window.x().step() * _scale_x) + window.x().step() * _scale_x - _x - _width;
 190             end     = std::max<int>(window.x().start(), end / _scale_x);
 191
 192             window.set(0, Window::Dimension(window.x().start(), end, window.x().step()));
 193             window_modified = true;
 194         }
 195     }
 196
 197     window.validate();
 198
 199     return window_modified;
 200 }
 201
 202 bool AccessWindowRectangle::update_padding_if_needed(const Window &window)
 203 {
 204     // Only update the padding if the tensor allows it
 205     if(_info == nullptr || !_info->is_resizable())
 206     {
 207         return false;
 208     }
 209
 210     ARM_COMPUTE_ERROR_ON(_scale_x == 0);
 211     ARM_COMPUTE_ERROR_ON(_scale_y == 0);
 212
 213     const int min_x = window.x().start() * _scale_x + _x;
 214     const int max_x = (window.x().end() - window.x().step()) * _scale_x + _x + _width;
 215     const int min_y = window.y().start() * _scale_y + _y;
 216     const int max_y = (window.y().end() - window.y().step()) * _scale_y + _y + _height;
 217
 218     const TensorShape &shape = _info->tensor_shape();
 219
 220     PaddingSize padding;
 221     padding.left   = std::max(0, -min_x);
 222     padding.right  = std::max<int>(0, max_x - shape[0]);
 223     padding.top    = std::max(0, -min_y);
 224     padding.bottom = std::max<int>(0, max_y - shape[1]);
 225
 226     // Update strides in tensor info
 227     return _info->extend_padding(padding);
 228 }