1 /*
2 * Copyright (c) 2017-2020 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 "src/core/AccessWindowTranspose.h"
25
26 #include "arm_compute/core/Helpers.h"
27 #include "arm_compute/core/ITensorInfo.h"
28 #include "arm_compute/core/Window.h"
29
30 using namespace arm_compute;
31
compute_valid_region(const Window & window,ValidRegion input_valid_region,bool border_undefined,BorderSize border_size) const32 ValidRegion AccessWindowTranspose::compute_valid_region(const Window &window, ValidRegion input_valid_region, bool border_undefined, BorderSize border_size) const
33 {
34 if(_info == nullptr)
35 {
36 return input_valid_region;
37 }
38
39 Coordinates &anchor = input_valid_region.anchor;
40 TensorShape &shape = input_valid_region.shape;
41 Coordinates old_anchor(anchor);
42 TensorShape old_shape(shape);
43
44 if(!border_undefined)
45 {
46 border_size = BorderSize(0);
47 }
48
49 // Start of the valid region is equal to the start of the window. But it
50 // cannot be less than the start of the input's valid region plus the border
51 // size required by this kernel (if undefined).
52 // Additionally the valid region is shifted by the offset that is used by
53 // the kernel to write back output values.
54 // As the relation between input and output is transposed window.y() is
55 // used for x anchor and window.x() for y anchor.
56 if(_info->dimension(0) > 1)
57 {
58 anchor.set(0, std::max<int>(window.y().start() * _scale_x, anchor[1] + border_size.top) + _x);
59 }
60 anchor.set(1, std::max<int>(window.x().start() * _scale_y, anchor[0] + border_size.left) + _y);
61
62 // End of the valid region is equal to the start of the last write of the
63 // kernel plus the number of written elements. (This assumes that all
64 // written elements are valid). Nevertheless the end cannot be larger than
65 // the end of the input's valid region minus the border size.
66 // Note: not the end points of the region are stored but its size. Thus the
67 // old size is first converted into end points to compared against the
68 // execution window. Afterwards the new end points are converted back into
69 // a size of the region.
70 // As the relation between input and output is transposed window.y() is
71 // used for x shape and window.x() for y shape.
72 if(_info->dimension(0) > 1)
73 {
74 shape.set(0, std::min<int>((old_anchor[1] + old_shape[0]) * _scale_x - border_size.right, (window.y().end() - window.y().step()) * _scale_x + _width) - anchor[0]);
75 }
76 shape.set(1, std::min<int>((old_anchor[0] + old_shape[1]) * _scale_y - border_size.bottom, (window.x().end() - window.x().step()) * _scale_y + _height) - anchor[1]);
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
update_window_if_needed(Window & window) const89 bool AccessWindowTranspose::update_window_if_needed(Window &window) const
90 {
91 // Only update the window size if we can't use padding
92 if(_info == nullptr || _info->is_resizable())
93 {
94 return false;
95 }
96
97 const TensorShape &shape = _info->tensor_shape();
98 const Strides &strides = _info->strides_in_bytes();
99 const size_t offset_first_element = _info->offset_first_element_in_bytes();
100
101 bool window_modified = false;
102
103 int front_pad_y = 0;
104
105 // Transpose and scale
106 const int min_y = window.x().start() * _scale_y + _y;
107 const int max_y = window.x().end() * _scale_y + _y;
108
109 // Adjust window start for output's Y dimension (so X in (input) window)
110 if(min_y < 0)
111 {
112 // Calculate rows available above the tensor
113 const int front_pad_y_available = -offset_first_element / strides[1];
114
115 if(min_y < front_pad_y_available)
116 {
117 // Not enough padding available, need to shrink the window
118 const int start = adjust_up(min_y, front_pad_y_available, window.x().step() * _scale_y) - _y;
119
120 window.set(0, Window::Dimension(start / _scale_y, window.x().end(), window.x().step()));
121 window_modified = true;
122 }
123
124 // Update front padding with reconstructed value
125 front_pad_y = std::max(0, static_cast<int>(std::floor(-window.x().start() * _scale_y)) - _y);
126 }
127
128 // Adjust window end for Y dimension
129 if(max_y > static_cast<int>(shape[1]))
130 {
131 const int stride_z = _info->num_dimensions() > 2 ? strides[2] : _info->total_size();
132
133 // Calculate rows available below the tensor
134 const int tail_pad_y_available = (stride_z / strides[1]) - shape[1] - front_pad_y;
135
136 if(static_cast<int>(shape[1]) + tail_pad_y_available < max_y)
137 {
138 // Not enough padding available, need to shrink the window
139 const int end = adjust_down(max_y, shape[1] + tail_pad_y_available, window.x().step() * _scale_y) + window.x().step() * _scale_y - _y - _height;
140 window.set(0, Window::Dimension(window.x().start(), end / _scale_y, window.x().step()));
141 window_modified = true;
142 }
143 }
144
145 int front_pad_x = 0;
146
147 // Transpose and scale
148 const int min_x = window.y().start() * _scale_x + _x;
149 const int max_x = window.y().end() * _scale_x + _x;
150
151 const int stride_y = _info->num_dimensions() > 1 ? strides[1] : _info->total_size();
152
153 // Adjust window start for X dimension
154 if(min_x < 0)
155 {
156 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]);
157
158 if(min_x < front_pad_x_available)
159 {
160 // Not enough padding available, need to shrink the window
161 const int start = adjust_up(min_x, front_pad_x_available, window.y().step() * _scale_x) - _x;
162 window.set(1, Window::Dimension(start / _scale_x, window.y().end(), window.y().step()));
163 window_modified = true;
164 }
165
166 // Update front padding with reconstructed value
167 front_pad_x = std::max(0, static_cast<int>(std::floor(-window.y().start() * _scale_x)) - _x);
168 }
169
170 // Adjust window end for X dimension
171 if(max_x > static_cast<int>(shape[0]))
172 {
173 const int tail_pad_x_available = (stride_y / strides[0]) - shape[0] - front_pad_x;
174
175 if(static_cast<int>(shape[0]) + tail_pad_x_available < max_x)
176 {
177 // Not enough padding available, need to shrink the window
178 const int end = adjust_down(max_x, shape[0] + tail_pad_x_available, window.y().step() * _scale_x) + window.y().step() * _scale_x - _x - _width;
179 window.set(1, Window::Dimension(window.y().start(), end / _scale_x, window.y().step()));
180 window_modified = true;
181 }
182 }
183
184 window.validate();
185
186 return window_modified;
187 }
188
update_padding_if_needed(const Window & window)189 bool AccessWindowTranspose::update_padding_if_needed(const Window &window)
190 {
191 // Only update the padding if the tensor allows it
192 if(_info == nullptr || !_info->is_resizable())
193 {
194 return false;
195 }
196
197 ARM_COMPUTE_ERROR_ON(window.y().step() == 0);
198 ARM_COMPUTE_ERROR_ON(window.x().step() == 0);
199
200 const int min_x = window.y().start() * _scale_x + _x;
201 const int max_x = (window.y().end() - window.y().step()) * _scale_x + _x + _width;
202 const int min_y = window.x().start() * _scale_y + _y;
203 const int max_y = (window.x().end() - window.x().step()) * _scale_y + _y + _height;
204
205 const TensorShape &shape = _info->tensor_shape();
206
207 PaddingSize padding;
208 padding.left = std::max(0, -min_x);
209 padding.right = std::max<int>(0, max_x - shape[0]);
210 padding.top = std::max(0, -min_y);
211 padding.bottom = std::max<int>(0, max_y - shape[1]);
212
213 // Update strides in tensor info
214 return _info->extend_padding(padding);
215 }
216