blob: 1ea0d2c23df6d3fef3ae1400d5db16ab15b86f50 [file] [log] [blame]
Anthony Barbier6ff3b192017-09-04 18:44:23 +01001/*
Michalis Spyrou702dc0c2021-03-19 15:06:07 +00002 * Copyright (c) 2017-2021 Arm Limited.
Anthony Barbier6ff3b192017-09-04 18:44:23 +01003 *
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 */
Sang-Hoon Parkbef7fa22020-10-21 15:58:54 +010024#include "src/core/CL/kernels/CLNormalizationLayerKernel.h"
Anthony Barbier6ff3b192017-09-04 18:44:23 +010025
26#include "arm_compute/core/CL/CLHelpers.h"
27#include "arm_compute/core/CL/CLKernelLibrary.h"
28#include "arm_compute/core/CL/ICLTensor.h"
29#include "arm_compute/core/Helpers.h"
30#include "arm_compute/core/TensorInfo.h"
31#include "arm_compute/core/Utils.h"
Anthony Barbier6ff3b192017-09-04 18:44:23 +010032#include "arm_compute/core/Window.h"
Sang-Hoon Park68dd25f2020-10-19 16:00:11 +010033#include "src/core/AccessWindowStatic.h"
34#include "src/core/CL/CLValidate.h"
35#include "src/core/helpers/AutoConfiguration.h"
36#include "src/core/helpers/NormalizationHelpers.h"
37#include "src/core/helpers/WindowHelpers.h"
Matthew Bentham758b5ba2020-03-05 23:37:48 +000038#include "support/StringSupport.h"
Anthony Barbier6ff3b192017-09-04 18:44:23 +010039
40using namespace arm_compute;
41
Giorgio Arenac23b6332017-11-28 15:23:51 +000042namespace
43{
Michele Di Giorgio9d3a8312018-11-20 12:31:24 +000044constexpr unsigned int num_elems_processed_per_iteration = 4;
Georgios Pinitas631c41a2017-12-06 11:53:03 +000045Status validate_arguments(const ITensorInfo *input, const ITensorInfo *output, NormalizationLayerInfo norm_info)
Giorgio Arenac23b6332017-11-28 15:23:51 +000046{
Vidhya Sudhan Loganathanf1f49062018-05-25 13:21:26 +010047 ARM_COMPUTE_RETURN_ERROR_ON_F16_UNSUPPORTED(input);
Vidhya Sudhan Loganathan7485d5a2018-07-04 09:34:00 +010048 ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input, 1, DataType::F16, DataType::F32);
Michele Di Giorgio9d3a8312018-11-20 12:31:24 +000049 ARM_COMPUTE_RETURN_ERROR_ON_DATA_LAYOUT_NOT_IN(input, DataLayout::NCHW, DataLayout::NHWC);
Giorgio Arenac23b6332017-11-28 15:23:51 +000050 ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR(output);
51
52 ARM_COMPUTE_RETURN_ERROR_ON_MSG(!(norm_info.norm_size() % 2), "Normalization size should be odd");
Giorgio Arenac23b6332017-11-28 15:23:51 +000053
Giorgio Arenac23b6332017-11-28 15:23:51 +000054 // Checks performed when output is configured
55 if(output->total_size() != 0)
56 {
57 ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_TYPES(input, output);
Michele Di Giorgio9d3a8312018-11-20 12:31:24 +000058 ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_LAYOUT(input, output);
Giorgio Arenac23b6332017-11-28 15:23:51 +000059 ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_SHAPES(input, output);
Giorgio Arenac23b6332017-11-28 15:23:51 +000060 }
61
Georgios Pinitas631c41a2017-12-06 11:53:03 +000062 return Status{};
Giorgio Arenac23b6332017-11-28 15:23:51 +000063}
64
Georgios Pinitas631c41a2017-12-06 11:53:03 +000065std::pair<Status, Window> validate_and_configure_window(ITensorInfo *input, ITensorInfo *output, NormalizationLayerInfo norm_info)
Giorgio Arenac23b6332017-11-28 15:23:51 +000066{
Giorgio Arenaf6a43c52017-12-01 12:16:25 +000067 // Output tensor auto initialization if not yet initialized
68 auto_init_if_empty(*output, *input->clone());
69
Georgios Pinitas7f32d012018-10-11 18:41:19 +010070 const unsigned int norm_idx = get_normalization_dimension_index(input->data_layout(), norm_info);
71 const bool is_norm_accross_width = norm_idx == 0;
72
73 const unsigned int border_width = is_norm_accross_width ? num_elems_processed_per_iteration - 1 : 0;
Giorgio Arenac23b6332017-11-28 15:23:51 +000074 const BorderSize border_size = BorderSize(0, border_width);
75
Georgios Pinitas7f32d012018-10-11 18:41:19 +010076 Window win = calculate_max_window(*input, Steps(num_elems_processed_per_iteration));
77 bool window_changed = false;
Giorgio Arenac23b6332017-11-28 15:23:51 +000078
Georgios Pinitas01624362017-11-30 10:53:31 +000079 // We do not use a Rectangle window for IN_MAP_2D as we clamp the top and bottom accesses inside the kernel, avoiding padding
Georgios Pinitas7f32d012018-10-11 18:41:19 +010080 // Reads can occur within the valid region of the input
81 if(is_norm_accross_width)
82 {
83 AccessWindowStatic input_access(input, -border_size.left, 0, input->dimension(0) + border_size.right, 0);
84 window_changed = window_changed || update_window_and_padding(win, input_access);
85 }
86 else
87 {
88 AccessWindowHorizontal input_access(input, -border_size.left, num_elems_processed_per_iteration);
89 window_changed = window_changed || update_window_and_padding(win, input_access);
90 }
91
Giorgio Arenac23b6332017-11-28 15:23:51 +000092 AccessWindowHorizontal output_access(output, 0, num_elems_processed_per_iteration);
Georgios Pinitas7f32d012018-10-11 18:41:19 +010093 window_changed = window_changed || update_window_and_padding(win, output_access);
Giorgio Arenac23b6332017-11-28 15:23:51 +000094
Georgios Pinitas631c41a2017-12-06 11:53:03 +000095 Status err = (window_changed) ? ARM_COMPUTE_CREATE_ERROR(ErrorCode::RUNTIME_ERROR, "Insufficient Padding!") : Status{};
Giorgio Arenac23b6332017-11-28 15:23:51 +000096 return std::make_pair(err, win);
97}
98} // namespace
99
Anthony Barbier6ff3b192017-09-04 18:44:23 +0100100CLNormalizationLayerKernel::CLNormalizationLayerKernel()
Georgios Pinitase2220552018-07-20 13:23:44 +0100101 : _input(nullptr), _output(nullptr), _border_size(0), _is_norm_across_width(false)
Anthony Barbier6ff3b192017-09-04 18:44:23 +0100102{
103}
104
105BorderSize CLNormalizationLayerKernel::border_size() const
106{
107 return _border_size;
108}
109
Gian Marco Iodiced60a6b92017-08-10 10:43:40 +0100110void CLNormalizationLayerKernel::configure(const ICLTensor *input, ICLTensor *output, NormalizationLayerInfo norm_info)
Anthony Barbier6ff3b192017-09-04 18:44:23 +0100111{
Manuel Bottini4c6bd512020-04-08 10:15:51 +0100112 configure(CLKernelLibrary::get().get_compile_context(), input, output, norm_info);
113}
114
Manuel Bottini679fc962020-04-21 16:08:53 +0100115void CLNormalizationLayerKernel::configure(const CLCompileContext &compile_context, const ICLTensor *input, ICLTensor *output, NormalizationLayerInfo norm_info)
Manuel Bottini4c6bd512020-04-08 10:15:51 +0100116{
Georgios Pinitas30902ed2017-11-14 15:32:57 +0000117 ARM_COMPUTE_ERROR_ON_NULLPTR(input, output);
Georgios Pinitas09004ca2017-07-03 17:30:14 +0100118
119 // Output tensor auto initialization if not yet initialized
Giorgio Arenaf6a43c52017-12-01 12:16:25 +0000120 auto_init_if_empty(*output->info(), *input->info()->clone());
Georgios Pinitas09004ca2017-07-03 17:30:14 +0100121
Georgios Pinitas30902ed2017-11-14 15:32:57 +0000122 // Perform validation step
Giorgio Arenaf6a43c52017-12-01 12:16:25 +0000123 ARM_COMPUTE_ERROR_THROW_ON(validate_arguments(input->info(), output->info(), norm_info));
Anthony Barbier6ff3b192017-09-04 18:44:23 +0100124
Gian Marco Iodiced60a6b92017-08-10 10:43:40 +0100125 _input = input;
126 _output = output;
Anthony Barbier6ff3b192017-09-04 18:44:23 +0100127
Georgios Pinitas7f32d012018-10-11 18:41:19 +0100128 const DataLayout data_layout = input->info()->data_layout();
129 const unsigned int norm_idx = get_normalization_dimension_index(data_layout, norm_info);
130 _is_norm_across_width = norm_idx == 0;
131 const unsigned int border_width = _is_norm_across_width ? num_elems_processed_per_iteration - 1 : 0;
132 _border_size = BorderSize(0, border_width);
133
Michele Di Giorgio9d3a8312018-11-20 12:31:24 +0000134 const bool is_in_map_2D = (norm_info.type() == NormType::IN_MAP_2D);
135
Michele Di Giorgio6c928342017-06-22 16:55:57 +0100136 // Set build options
Georgios Pinitas01624362017-11-30 10:53:31 +0000137 CLBuildOptions build_opts;
138 build_opts.add_option(("-DDATA_TYPE=" + get_cl_type_from_data_type(input->info()->data_type())));
Georgios Pinitas01624362017-11-30 10:53:31 +0000139 build_opts.add_option(("-DCOEFF=" + float_to_string_with_full_precision(norm_info.scale_coeff())));
140 build_opts.add_option(("-DBETA=" + float_to_string_with_full_precision(norm_info.beta())));
141 build_opts.add_option(("-DKAPPA=" + float_to_string_with_full_precision(norm_info.kappa())));
142 build_opts.add_option(("-DVEC_SIZE=" + support::cpp11::to_string(num_elems_processed_per_iteration)));
143 build_opts.add_option(("-DRADIUS=" + support::cpp11::to_string(norm_info.norm_size() / 2)));
144 build_opts.add_option(("-DNUM_SLICES=" + support::cpp11::to_string(input->info()->dimension(2))));
145 build_opts.add_option_if(is_in_map_2D, "-DIN_MAP_2D");
Georgios Pinitas7f32d012018-10-11 18:41:19 +0100146 build_opts.add_option_if(norm_info.is_in_map() || (data_layout == DataLayout::NHWC && norm_info.is_cross_map()), "-DWIDTH_SIZE=" + support::cpp11::to_string(input->info()->dimension(0)));
Michele Di Giorgio6c928342017-06-22 16:55:57 +0100147
Anthony Barbier6ff3b192017-09-04 18:44:23 +0100148 // Create kernel
Michele Di Giorgio9d3a8312018-11-20 12:31:24 +0000149 std::string kernel_name;
150 if(norm_info.is_in_map())
151 {
152 kernel_name = "normalization_layer_in_map_" + lower_string(string_from_data_layout(data_layout));
153 }
154 else
155 {
156 if(data_layout == DataLayout::NCHW)
157 {
158 kernel_name = "normalization_layer_cross_map";
159 }
160 else
161 {
162 // 1D Cross-Map normalization in NHWC is the same as 1D In-Map normalization in NCHW
163 kernel_name = "normalization_layer_in_map_nchw";
164 }
165 }
Manuel Bottini4c6bd512020-04-08 10:15:51 +0100166 _kernel = create_kernel(compile_context, kernel_name, build_opts.options());
Anthony Barbier6ff3b192017-09-04 18:44:23 +0100167
Anthony Barbier6ff3b192017-09-04 18:44:23 +0100168 // Configure kernel window
Georgios Pinitas01624362017-11-30 10:53:31 +0000169 auto win_config = validate_and_configure_window(input->info(), output->info(), norm_info);
Giorgio Arenac23b6332017-11-28 15:23:51 +0000170 ARM_COMPUTE_ERROR_THROW_ON(win_config.first);
Anthony Barbierb6eb3532018-08-08 13:20:04 +0100171 ICLKernel::configure_internal(win_config.second);
Giorgio Arena63485ce2017-11-15 16:04:20 +0000172
173 // Set config_id for enabling LWS tuning
174 _config_id = "normalization_layer_";
175 _config_id += lower_string(string_from_data_type(input->info()->data_type()));
176 _config_id += "_";
177 _config_id += support::cpp11::to_string(static_cast<std::underlying_type<NormType>::type>(norm_info.type()));
178 _config_id += "_";
179 _config_id += support::cpp11::to_string(norm_info.norm_size());
180 _config_id += "_";
181 _config_id += support::cpp11::to_string(input->info()->dimension(0));
182 _config_id += "_";
183 _config_id += support::cpp11::to_string(input->info()->dimension(1));
Anthony Barbier6ff3b192017-09-04 18:44:23 +0100184}
185
Georgios Pinitas631c41a2017-12-06 11:53:03 +0000186Status CLNormalizationLayerKernel::validate(const ITensorInfo *input, const ITensorInfo *output, NormalizationLayerInfo norm_info)
Georgios Pinitas30902ed2017-11-14 15:32:57 +0000187{
Giorgio Arenac23b6332017-11-28 15:23:51 +0000188 ARM_COMPUTE_RETURN_ON_ERROR(validate_arguments(input, output, norm_info));
Georgios Pinitas01624362017-11-30 10:53:31 +0000189 ARM_COMPUTE_RETURN_ON_ERROR(validate_and_configure_window(input->clone().get(), output->clone().get(), norm_info).first);
Georgios Pinitas30902ed2017-11-14 15:32:57 +0000190
Georgios Pinitas631c41a2017-12-06 11:53:03 +0000191 return Status{};
Georgios Pinitas30902ed2017-11-14 15:32:57 +0000192}
193
Anthony Barbier6ff3b192017-09-04 18:44:23 +0100194void CLNormalizationLayerKernel::run(const Window &window, cl::CommandQueue &queue)
195{
196 ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);
197 ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(IKernel::window(), window);
198
Georgios Pinitase2220552018-07-20 13:23:44 +0100199 const int collapsed_dimension = _is_norm_across_width ? Window::DimZ : 4;
steniu01f70256b2017-07-13 14:03:35 +0100200 Window window_collapsed = window.collapse_if_possible(ICLKernel::window(), collapsed_dimension);
201 Window slice = window_collapsed.first_slice_window_3D();
Anthony Barbier6ff3b192017-09-04 18:44:23 +0100202
203 do
204 {
205 unsigned int idx = 0;
206 add_3D_tensor_argument(idx, _input, slice);
Anthony Barbier6ff3b192017-09-04 18:44:23 +0100207 add_3D_tensor_argument(idx, _output, slice);
Anthony Barbier5a65cfd2018-08-10 14:10:08 +0100208 enqueue(queue, *this, slice, lws_hint());
Anthony Barbier6ff3b192017-09-04 18:44:23 +0100209 }
steniu01f70256b2017-07-13 14:03:35 +0100210 while(window_collapsed.slide_window_slice_3D(slice));
Anthony Barbier6ff3b192017-09-04 18:44:23 +0100211}