2 * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
18 * Copyright (c) 2017-2019 ARM Limited.
20 * SPDX-License-Identifier: MIT
22 * Permission is hereby granted, free of charge, to any person obtaining a copy
23 * of this software and associated documentation files (the "Software"), to
24 * deal in the Software without restriction, including without limitation the
25 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
26 * sell copies of the Software, and to permit persons to whom the Software is
27 * furnished to do so, subject to the following conditions:
29 * The above copyright notice and this permission notice shall be included in all
30 * copies or substantial portions of the Software.
32 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
33 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
34 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
35 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
36 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
37 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
41 #include "arm_compute/core/CL/kernels/CLQuantizationSymmetricKernel.h"
43 #include "arm_compute/core/AccessWindowStatic.h"
44 #include "arm_compute/core/CL/CLHelpers.h"
45 #include "arm_compute/core/CL/CLKernelLibraryEx.h"
46 #include "arm_compute/core/CL/CLValidate.h"
47 #include "arm_compute/core/CL/ICLTensor.h"
48 #include "arm_compute/core/TensorInfo.h"
49 #include "arm_compute/core/Utils.h"
50 #include "arm_compute/core/Validate.h"
51 #include "arm_compute/core/Window.h"
52 #include "support/StringSupport.h"
58 Status validate_arguments(const ITensorInfo *input, const ITensorInfo *scale_factor,
59 const ITensorInfo *output)
61 ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR(input, output);
62 ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input, 1, DataType::F32, DataType::F16);
63 ARM_COMPUTE_RETURN_ERROR_ON(input->num_dimensions() > 2);
64 ARM_COMPUTE_RETURN_ERROR_ON_F16_UNSUPPORTED(input);
66 ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_TYPES(input, scale_factor);
67 ARM_COMPUTE_RETURN_ERROR_ON(scale_factor->tensor_shape().total_size() == 0);
68 ARM_COMPUTE_RETURN_ERROR_ON(scale_factor->num_dimensions() > 1);
69 ARM_COMPUTE_RETURN_ERROR_ON(scale_factor->dimension(0) != input->dimension(1));
71 // Output must always be initialized
72 ARM_COMPUTE_RETURN_ERROR_ON(output->tensor_shape().total_size() == 0);
73 ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(output, 1, DataType::QASYMM8_SIGNED);
74 ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_SHAPES(input, output);
79 std::pair<Status, Window> validate_and_configure_window(ITensorInfo *input, ITensorInfo *output)
81 // Configure kernel window
82 Window win = calculate_max_window(*input, Steps());
84 const int vec_size_x = 16 / input->element_size();
85 const int input_width_x = input->tensor_shape().x();
86 const bool multi_access_x = (input_width_x / vec_size_x > 0);
91 Window::Dimension(win.x().start(), ceil_to_multiple(win.x().end(), vec_size_x),
96 coord.set_num_dimensions(output->num_dimensions());
97 output->set_valid_region(ValidRegion(coord, output->tensor_shape()));
99 return std::make_pair(Status{}, win);
103 CLQuantizationSymmetricKernel::CLQuantizationSymmetricKernel()
104 : _input(nullptr), _scale_factor(nullptr), _output(nullptr)
108 void CLQuantizationSymmetricKernel::configure(const ICLTensor *input, const ICLTensor *scale_factor,
111 ARM_COMPUTE_ERROR_ON_NULLPTR(input, scale_factor, output);
112 ARM_COMPUTE_ERROR_THROW_ON(
113 validate_arguments(input->info(), scale_factor->info(), output->info()));
116 _scale_factor = scale_factor;
119 const int vec_size_x = 16 / input->info()->element_size();
120 const int input_width_x = input->info()->tensor_shape().x();
121 const bool multi_access_x = (input_width_x / vec_size_x > 0);
123 // Configure kernel window
124 auto win_config = validate_and_configure_window(input->info(), output->info());
125 ARM_COMPUTE_ERROR_THROW_ON(win_config.first);
126 ICLKernel::configure_internal(win_config.second);
129 CLBuildOptions build_opts;
130 build_opts.add_option("-DVEC_SIZE=" + support::cpp11::to_string(vec_size_x));
131 build_opts.add_option("-DDATA_TYPE_IN=" + get_cl_type_from_data_type(input->info()->data_type()));
132 build_opts.add_option("-DDATA_TYPE_OUT=" +
133 get_cl_type_from_data_type(output->info()->data_type()));
134 build_opts.add_option_if(
135 multi_access_x, "-DLAST_ACCESSED_X=" +
136 support::cpp11::to_string(std::max<int>(input_width_x - vec_size_x, 0)));
138 _kernel = static_cast<cl::Kernel>(
139 CLKernelLibraryEx::get().create_kernel("quantization_symm8", build_opts.options()));
142 Status CLQuantizationSymmetricKernel::validate(const ITensorInfo *input,
143 const ITensorInfo *scale_factor,
144 const ITensorInfo *output)
146 ARM_COMPUTE_RETURN_ON_ERROR(validate_arguments(input, scale_factor, output));
147 ARM_COMPUTE_RETURN_ON_ERROR(
148 validate_and_configure_window(input->clone().get(), output->clone().get()).first);
153 void CLQuantizationSymmetricKernel::run(const Window &window, cl::CommandQueue &queue)
155 ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);
156 ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(ICLKernel::window(), window);
159 Window window_collapsed = window.collapse_if_possible(ICLKernel::window(), Window::DimZ);
160 Window slice = window_collapsed.first_slice_window_2D();
164 Window scale_slice = slice.shift_dimensions(1);
166 unsigned int idx = 0;
167 add_2D_tensor_argument(idx, _input, slice);
168 add_1D_tensor_argument(idx, _scale_factor, scale_slice);
169 add_2D_tensor_argument(idx, _output, slice);
170 enqueue(queue, *this, slice, lws_hint());
171 } while (window_collapsed.slide_window_slice_2D(slice));
173 } // namespace arm_compute