Compute Library
 21.02
CLGaussianPyramidKernel.cpp
Go to the documentation of this file.
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  */
25 
29 #include "arm_compute/core/Utils.h"
32 #include "support/StringSupport.h"
33 
34 using namespace arm_compute;
35 
37  : _l2_load_offset(0)
38 {
39 }
40 
42 {
43  return BorderSize{ 0, 2 };
44 }
45 
47 {
48  configure(CLKernelLibrary::get().get_compile_context(), input, output);
49 }
50 
52 {
55  ARM_COMPUTE_ERROR_ON(input->info()->dimension(1) != output->info()->dimension(1));
56 
57  for(size_t i = 2; i < Coordinates::num_max_dimensions; ++i)
58  {
59  ARM_COMPUTE_ERROR_ON(input->info()->dimension(i) != output->info()->dimension(i));
60  }
61 
62  _input = input;
63  _output = output;
64 
65  // Create kernel
66  const std::string kernel_name = std::string("gaussian1x5_sub_x");
67  _kernel = create_kernel(compile_context, kernel_name);
68 
69  // Configure kernel window
70  constexpr unsigned int num_elems_processed_per_iteration = 16;
71  constexpr unsigned int num_elems_read_per_iteration = 20;
72  constexpr unsigned int num_elems_written_per_iteration = 8;
73  const float scale_x = static_cast<float>(output->info()->dimension(0)) / input->info()->dimension(0);
74 
75  Window win = calculate_max_window_horizontal(*input->info(), Steps(num_elems_processed_per_iteration));
76  AccessWindowHorizontal output_access(output->info(), 0, num_elems_written_per_iteration, scale_x);
77 
78  // Sub sampling selects odd pixels (1, 3, 5, ...) for images with even
79  // width and even pixels (0, 2, 4, ...) for images with odd width. (Whether
80  // a pixel is even or odd is determined based on the tensor shape not the
81  // valid region!)
82  // Thus the offset from which the first pixel (L2) for the convolution is
83  // loaded depends on the anchor and shape of the valid region.
84  // In the case of an even shape (= even image width) we need to load L2
85  // from -2 if the anchor is odd and from -1 if the anchor is even. That
86  // makes sure that L2 is always loaded from an odd pixel.
87  // On the other hand, for an odd shape (= odd image width) we need to load
88  // L2 from -1 if the anchor is odd and from -2 if the anchor is even to
89  // achieve the opposite effect.
90  // The condition can be simplified to checking whether anchor + shape is
91  // odd (-2) or even (-1) as only adding an odd and an even number will have
92  // an odd result.
93  _l2_load_offset = -border_size().left;
94 
95  if((_input->info()->valid_region().anchor[0] + _input->info()->valid_region().shape[0]) % 2 == 0)
96  {
97  _l2_load_offset += 1;
98  }
99 
101  AccessWindowHorizontal(input->info(), _l2_load_offset, num_elems_read_per_iteration),
102  output_access);
103 
104  output->info()->set_valid_region(ValidRegion(Coordinates(), output->info()->tensor_shape()));
105 
106  ICLKernel::configure_internal(win);
107 
108  // Set config_id for enabling LWS tuning
109  _config_id = kernel_name;
110  _config_id += "_";
111  _config_id += lower_string(string_from_data_type(input->info()->data_type()));
112  _config_id += "_";
113  _config_id += support::cpp11::to_string(input->info()->dimension(0));
114  _config_id += "_";
115  _config_id += support::cpp11::to_string(input->info()->dimension(1));
116  _config_id += "_";
117  _config_id += support::cpp11::to_string(output->info()->dimension(0));
118  _config_id += "_";
119  _config_id += support::cpp11::to_string(output->info()->dimension(1));
120 }
121 
122 void CLGaussianPyramidHorKernel::run(const Window &window, cl::CommandQueue &queue)
123 {
126 
127  Window win_in(window);
128  win_in.shift(Window::DimX, _l2_load_offset);
129 
130  //The output is half the width of the input:
131  Window win_out(window);
132  win_out.scale(Window::DimX, 0.5f);
133 
134  Window slice_in = win_in.first_slice_window_2D();
135  Window slice_out = win_out.first_slice_window_2D();
136 
137  do
138  {
139  unsigned int idx = 0;
140  add_2D_tensor_argument(idx, _input, slice_in);
141  add_2D_tensor_argument(idx, _output, slice_out);
142  enqueue(queue, *this, slice_out, lws_hint());
143  }
144  while(win_in.slide_window_slice_2D(slice_in) && win_out.slide_window_slice_2D(slice_out));
145 }
146 
148  : _t2_load_offset(0)
149 {
150 }
151 
153 {
154  return BorderSize{ 2, 0 };
155 }
156 
158 {
159  configure(CLKernelLibrary::get().get_compile_context(), input, output);
160 }
161 
163 {
166  ARM_COMPUTE_ERROR_ON(input->info()->dimension(0) != output->info()->dimension(0));
167 
168  for(size_t i = 2; i < Coordinates::num_max_dimensions; ++i)
169  {
170  ARM_COMPUTE_ERROR_ON(input->info()->dimension(i) != output->info()->dimension(i));
171  }
172 
173  _input = input;
174  _output = output;
175 
176  // Create kernel
177  const std::string kernel_name = std::string("gaussian5x1_sub_y");
178  _kernel = create_kernel(compile_context, "gaussian5x1_sub_y");
179 
180  // Configure kernel window
181  constexpr unsigned int num_elems_processed_per_iteration = 8;
182  constexpr unsigned int num_rows_processed_per_iteration = 2;
183  constexpr unsigned int num_elems_written_per_iteration = 8;
184  constexpr unsigned int num_elems_read_per_iteration = 8;
185  constexpr unsigned int num_rows_per_iteration = 5;
186 
187  const float scale_y = static_cast<float>(output->info()->dimension(1)) / input->info()->dimension(1);
188 
189  Window win = calculate_max_window(*input->info(), Steps(num_elems_processed_per_iteration, num_rows_processed_per_iteration));
190  AccessWindowRectangle output_access(output->info(), 0, 0, num_elems_written_per_iteration, num_rows_per_iteration, 1.f, scale_y);
191 
192  // Determine whether we need to load even or odd rows. See above for a
193  // detailed explanation.
194  _t2_load_offset = -border_size().top;
195 
196  if((_input->info()->valid_region().anchor[1] + _input->info()->valid_region().shape[1]) % 2 == 0)
197  {
198  _t2_load_offset += 1;
199  }
200 
202  AccessWindowRectangle(input->info(), 0, _t2_load_offset, num_elems_read_per_iteration, num_rows_per_iteration),
203  output_access);
204 
205  output->info()->set_valid_region(ValidRegion(Coordinates(), output->info()->tensor_shape()));
206 
207  ICLKernel::configure_internal(win);
208 
209  // Set config_id for enabling LWS tuning
210  _config_id = kernel_name;
211  _config_id += "_";
212  _config_id += lower_string(string_from_data_type(input->info()->data_type()));
213  _config_id += "_";
214  _config_id += support::cpp11::to_string(input->info()->dimension(0));
215  _config_id += "_";
216  _config_id += support::cpp11::to_string(input->info()->dimension(1));
217  _config_id += "_";
218  _config_id += support::cpp11::to_string(output->info()->dimension(0));
219  _config_id += "_";
220  _config_id += support::cpp11::to_string(output->info()->dimension(1));
221 }
222 
223 void CLGaussianPyramidVertKernel::run(const Window &window, cl::CommandQueue &queue)
224 {
227  ARM_COMPUTE_ERROR_ON(window.x().step() != 8);
228  ARM_COMPUTE_ERROR_ON(window.y().step() % 2);
229 
230  Window win_in(window);
231  win_in.shift(Window::DimY, _t2_load_offset);
232 
233  Window win_out(window);
234  win_out.scale(Window::DimY, 0.5f);
235 
236  Window slice_in = win_in.first_slice_window_2D();
237  Window slice_out = win_out.first_slice_window_2D();
238 
239  do
240  {
241  unsigned int idx = 0;
242  add_2D_tensor_argument(idx, _input, slice_in);
243  add_2D_tensor_argument(idx, _output, slice_out);
244  enqueue(queue, *this, slice_out, lws_hint());
245  }
246  while(win_in.slide_window_slice_2D(slice_in) && win_out.slide_window_slice_2D(slice_out));
247 }
BorderSize border_size() const override
The size of the border for that kernel.
Window first_slice_window_2D() const
First 2D slice of the window.
Definition: Window.h:283
unsigned int top
top of the border
Definition: Types.h:375
void scale(size_t dimension, float scale_value)
Scale the values of a given dimension by the given scale_value.
Definition: Window.inl:155
Window calculate_max_window(const ValidRegion &valid_region, const Steps &steps, bool skip_border, BorderSize border_size)
const Window & window() const
The maximum window the kernel can be executed on.
Definition: IKernel.cpp:28
void configure(const ICLTensor *input, ICLTensor *output)
Initialise the kernel&#39;s source, destination and border mode.
void enqueue(IGCKernel &kernel, const Window &window, const gles::NDRange &lws=gles::NDRange(1U, 1U, 1U))
Add the kernel to the command queue with the given window.
Definition: IGCKernel.cpp:41
virtual size_t dimension(size_t index) const =0
Return the size of the requested dimension.
void shift(size_t dimension, int shift_value)
Shift the values of a given dimension by the given shift_value.
Definition: Window.inl:133
Container for 2D border size.
Definition: Types.h:273
constexpr int step() const
Return the step of the dimension.
Definition: Window.h:104
cl::NDRange lws_hint() const
Return the Local-Workgroup-Size hint.
Definition: ICLKernel.h:276
1 channel, 1 U8 per channel
std::string to_string(T &&value)
Convert integer and float values to string.
virtual DataType data_type() const =0
Data type used for each element of the tensor.
#define ARM_COMPUTE_ERROR_ON(cond)
If the condition is true then an error message is printed and an exception thrown.
Definition: Error.h:466
static CLKernelLibrary & get()
Access the KernelLibrary singleton.
1 channel, 1 U16 per channel
std::string lower_string(const std::string &val)
Lower a given string.
Definition: Utils.cpp:350
Window calculate_max_window_horizontal(const ValidRegion &valid_region, const Steps &steps, bool skip_border, BorderSize border_size)
bool slide_window_slice_2D(Window &slice) const
Slide the passed 2D window slice.
Definition: Window.h:323
Copyright (c) 2017-2021 Arm Limited.
virtual void set_valid_region(const ValidRegion &valid_region)=0
Set the valid region of the tensor.
void configure(const ICLTensor *input, ICLTensor *output)
Initialise the kernel&#39;s source, destination and border mode.
Implementation of a rectangular access pattern.
cl::Kernel create_kernel(const CLCompileContext &ctx, const std::string &kernel_name, const std::set< std::string > &build_opts=std::set< std::string >())
Creates an opencl kernel using a compile context.
Definition: CLHelpers.cpp:403
const std::string & string_from_data_type(DataType dt)
Convert a data type identity into a string.
Definition: Utils.cpp:135
static constexpr size_t DimX
Alias for dimension 0 also known as X dimension.
Definition: Window.h:43
bool update_window_and_padding(Window &win, Ts &&... patterns)
Update window and padding size for each of the access patterns.
Definition: WindowHelpers.h:46
virtual const TensorShape & tensor_shape() const =0
Size for each dimension of the tensor.
Class to describe a number of elements in each dimension.
Definition: Steps.h:40
Coordinates of an item.
Definition: Coordinates.h:37
Implementation of a row access pattern.
std::string kernel_name
virtual ITensorInfo * info() const =0
Interface to be implemented by the child class to return the tensor&#39;s metadata.
unsigned int left
left of the border
Definition: Types.h:378
#define ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(k)
Definition: Validate.h:941
#define ARM_COMPUTE_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(t, c,...)
Definition: Validate.h:790
CLCompileContext class.
void run(const Window &window, cl::CommandQueue &queue) override
Enqueue the OpenCL kernel to process the given window on the passed OpenCL command queue...
static constexpr size_t DimY
Alias for dimension 1 also known as Y dimension.
Definition: Window.h:45
void add_2D_tensor_argument(unsigned int &idx, const ICLTensor *tensor, const Window &window)
Add the passed 2D tensor&#39;s parameters to the object&#39;s kernel&#39;s arguments starting from the index idx...
Definition: ICLKernel.h:148
Interface for OpenCL tensor.
Definition: ICLTensor.h:42
Manages all the OpenCL kernels compilation and caching, provides accessors for the OpenCL Context...
BorderSize border_size() const override
The size of the border for that kernel.
constexpr const Dimension & y() const
Alias to access the second dimension of the window.
Definition: Window.h:154
unsigned int num_elems_processed_per_iteration
void run(const Window &window, cl::CommandQueue &queue) override
Enqueue the OpenCL kernel to process the given window on the passed OpenCL command queue...
Container for valid region of a window.
Definition: Types.h:188
static constexpr size_t num_max_dimensions
Number of dimensions the tensor has.
Definition: Dimensions.h:46
Describe a multidimensional execution window.
Definition: Window.h:39
#define ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(f, s)
Definition: Validate.h:205
constexpr const Dimension & x() const
Alias to access the first dimension of the window.
Definition: Window.h:145