src/core/CL/kernels/CLDepthwiseConvolutionLayer3x3Kernel.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/CL/kernels/CLDepthwiseConvolutionLayer3x3Kernel.h"
  25
  26 #include "arm_compute/core/AccessWindowStatic.h"
  27 #include "arm_compute/core/CL/CLHelpers.h"
  28 #include "arm_compute/core/CL/CLKernelLibrary.h"
  29 #include "arm_compute/core/CL/ICLKernel.h"
  30 #include "arm_compute/core/CL/ICLTensor.h"
  31 #include "arm_compute/core/Error.h"
  32 #include "arm_compute/core/Helpers.h"
  33 #include "arm_compute/core/TensorInfo.h"
  34 #include "arm_compute/core/Types.h"
  35 #include "arm_compute/core/Utils.h"
  36 #include "arm_compute/core/utils/misc/ShapeCalculator.h"
  37 #include "arm_compute/core/utils/quantization/AsymmHelpers.h"
  38
  39 using namespace arm_compute;
  40 using namespace arm_compute::misc::shape_calculator;
  41
  42 CLDepthwiseConvolutionLayer3x3Kernel::CLDepthwiseConvolutionLayer3x3Kernel()
  43     : _border_size(0), _input(), _output(), _weights(), _biases(), _conv_stride_x(0), _conv_stride_y(0), _conv_pad_left(0), _conv_pad_top(0)
  44 {
  45 }
  46
  47 BorderSize CLDepthwiseConvolutionLayer3x3Kernel::border_size() const
  48 {
  49     return _border_size;
  50 }
  51
  52 void CLDepthwiseConvolutionLayer3x3Kernel::configure(const ICLTensor *input, const ICLTensor *weights, const ICLTensor *biases, ICLTensor *output, const PadStrideInfo &conv_info)
  53 {
  54     ARM_COMPUTE_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input, 1, DataType::QASYMM8, DataType::F16, DataType::F32);
  55     ARM_COMPUTE_ERROR_ON_MISMATCHING_DATA_TYPES(input, weights);
  56     ARM_COMPUTE_ERROR_ON(weights->info()->dimension(0) != 3 || weights->info()->dimension(1) != 3);
  57
  58     bool is_qasymm = is_data_type_quantized_asymmetric(input->info()->data_type());
  59
  60     if(biases != nullptr)
  61     {
  62         if(is_qasymm)
  63         {
  64             ARM_COMPUTE_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(biases, 1, DataType::S32);
  65         }
  66         else
  67         {
  68             ARM_COMPUTE_ERROR_ON_MISMATCHING_DATA_TYPES(weights, biases);
  69         }
  70         ARM_COMPUTE_ERROR_ON(biases->info()->dimension(0) != weights->info()->dimension(2));
  71         ARM_COMPUTE_ERROR_ON(biases->info()->num_dimensions() > 1);
  72     }
  73
  74     // Get convolved dimensions
  75     const TensorShape output_shape = compute_depthwise_convolution_shape(*input->info(), *weights->info(), conv_info);
  76
  77     // Output auto inizialitation if not yet initialized
  78     auto_init_if_empty(*output->info(),
  79                        output_shape,
  80                        1,
  81                        input->info()->data_type(),
  82                        input->info()->fixed_point_position(),
  83                        input->info()->quantization_info());
  84
  85     ARM_COMPUTE_ERROR_ON_MISMATCHING_DIMENSIONS(output->info()->tensor_shape(), output_shape);
  86
  87     _input         = input;
  88     _output        = output;
  89     _weights       = weights;
  90     _biases        = biases;
  91     _conv_stride_x = conv_info.stride().first;
  92     _conv_stride_y = conv_info.stride().second;
  93     _conv_pad_left = conv_info.pad_left();
  94     _conv_pad_top  = conv_info.pad_top();
  95     _border_size   = BorderSize(_conv_pad_top, conv_info.pad_right(), conv_info.pad_bottom(), _conv_pad_left);
  96
  97     // Set build options
  98     ARM_COMPUTE_ERROR_ON(_conv_stride_x < 1 || _conv_stride_x > 3);
  99     CLBuildOptions build_opts;
 100     build_opts.add_option("-DCONV_STRIDE_X=" + support::cpp11::to_string(_conv_stride_x));
 101     build_opts.add_option_if(_biases != nullptr, "-DHAS_BIAS");
 102
 103     if(is_qasymm)
 104     {
 105         float multiplier        = _input->info()->quantization_info().scale * _weights->info()->quantization_info().scale / _output->info()->quantization_info().scale;
 106         int   output_multiplier = 0;
 107         int   output_shift      = 0;
 108         quantization::calculate_quantized_multiplier_less_than_one(multiplier, &output_multiplier, &output_shift);
 109
 110         build_opts.add_option("-DCONV_STRIDE_Y=" + support::cpp11::to_string(_conv_stride_y));
 111         build_opts.add_option("-DINPUT_OFFSET=" + support::cpp11::to_string(-_input->info()->quantization_info().offset));
 112         build_opts.add_option("-DWEIGHTS_OFFSET=" + support::cpp11::to_string(-_weights->info()->quantization_info().offset));
 113         build_opts.add_option("-DOUTPUT_OFFSET=" + support::cpp11::to_string(_output->info()->quantization_info().offset));
 114         build_opts.add_option("-DK_OFFSET=" + support::cpp11::to_string(9 * input->info()->quantization_info().offset * weights->info()->quantization_info().offset));
 115         build_opts.add_option("-DOUTPUT_MULTIPLIER=" + support::cpp11::to_string(output_multiplier));
 116         build_opts.add_option("-DOUTPUT_SHIFT=" + support::cpp11::to_string(output_shift));
 117     }
 118
 119     // Configure the local work size for Bifrost with a value obtained
 120     // via exhaustive autotuning for the MobileNets tensor shapes.
 121     const GPUTarget gpu_target = get_arch_from_target(get_target());
 122
 123     // Configure kernel window
 124     unsigned int num_elems_read_per_iteration_x    = 0;
 125     unsigned int num_elems_read_per_iteration_y    = 0;
 126     unsigned int num_elems_written_per_iteration_x = 0;
 127     unsigned int num_elems_written_per_iteration_y = 0;
 128
 129     // Create kernel
 130     std::string kernel_name;
 131
 132     if(input->info()->data_type() == DataType::F16)
 133     {
 134         kernel_name                       = "depthwise_convolution_3x3_f16";
 135         num_elems_written_per_iteration_x = 8 / data_size_from_type(input->info()->data_type());
 136         num_elems_written_per_iteration_y = 1;
 137         num_elems_read_per_iteration_y    = 3;
 138         switch(_conv_stride_x)
 139         {
 140             case 1:
 141                 num_elems_read_per_iteration_x = 8;
 142                 break;
 143             case 2:
 144                 num_elems_read_per_iteration_x = 9;
 145                 break;
 146             case 3:
 147                 num_elems_read_per_iteration_x = 16;
 148                 break;
 149             default:
 150                 num_elems_read_per_iteration_x = 3 + (num_elems_written_per_iteration_x - 1) * _conv_stride_x;
 151                 break;
 152         }
 153     }
 154     else if(input->info()->data_type() == DataType::F32 && gpu_target == GPUTarget::BIFROST)
 155     {
 156         if(_conv_stride_x == 1 && _conv_stride_y == 1)
 157         {
 158             kernel_name                       = "depthwise_convolution_3x3_stridex1_stridey1_bifrost";
 159             num_elems_read_per_iteration_x    = 4;
 160             num_elems_read_per_iteration_y    = 6;
 161             num_elems_written_per_iteration_x = 2;
 162             num_elems_written_per_iteration_y = 4;
 163         }
 164         else if(_conv_stride_x == 2 && _conv_stride_y == 2)
 165         {
 166             kernel_name                       = "depthwise_convolution_3x3_stridex2_stridey2_bifrost";
 167             num_elems_read_per_iteration_x    = 6;
 168             num_elems_read_per_iteration_y    = 5;
 169             num_elems_written_per_iteration_x = 2;
 170             num_elems_written_per_iteration_y = 2;
 171         }
 172         else
 173         {
 174             kernel_name                       = "depthwise_convolution_3x3";
 175             num_elems_written_per_iteration_x = 8 / data_size_from_type(input->info()->data_type());
 176             num_elems_written_per_iteration_y = 1;
 177             num_elems_read_per_iteration_x    = 3 + (num_elems_written_per_iteration_x - 1) * _conv_stride_x;
 178             num_elems_read_per_iteration_y    = 3;
 179         }
 180     }
 181     else
 182     {
 183         kernel_name                       = is_qasymm ? "depthwise_convolution_3x3_quantized" : "depthwise_convolution_3x3";
 184         num_elems_written_per_iteration_x = 8 / data_size_from_type(input->info()->data_type());
 185         num_elems_written_per_iteration_y = (is_qasymm && _conv_stride_y < 3) ? (2 / _conv_stride_y) : 1;
 186         num_elems_read_per_iteration_x    = 3 + (num_elems_written_per_iteration_x - 1) * _conv_stride_x;
 187         num_elems_read_per_iteration_y    = num_elems_written_per_iteration_y + 2;
 188     }
 189
 190     // Create window and update padding
 191     Window win = calculate_max_window(*output->info(), Steps(num_elems_written_per_iteration_x, num_elems_written_per_iteration_y));
 192
 193     AccessWindowRectangle input_access(input->info(), -_conv_pad_left, -_conv_pad_top,
 194                                        num_elems_read_per_iteration_x, num_elems_read_per_iteration_y,
 195                                        _conv_stride_x, _conv_stride_y);
 196     AccessWindowStatic    weights_access(weights->info(), 0, 0, 3, 3);
 197     AccessWindowRectangle output_access(output->info(), 0, 0, num_elems_written_per_iteration_x, num_elems_written_per_iteration_y);
 198
 199     update_window_and_padding(win, input_access, weights_access, output_access);
 200
 201     output_access.set_valid_region(win, ValidRegion(Coordinates(), output->info()->tensor_shape()));
 202
 203     ICLKernel::configure(win);
 204
 205     _kernel = static_cast<cl::Kernel>(CLKernelLibrary::get().create_kernel(kernel_name, build_opts.options()));
 206
 207     // Set config_id for enabling LWS tuning
 208     _config_id = kernel_name;
 209     _config_id += "_";
 210     _config_id += lower_string(string_from_data_type(input->info()->data_type()));
 211     _config_id += "_";
 212     _config_id += support::cpp11::to_string(input->info()->dimension(0));
 213     _config_id += "_";
 214     _config_id += support::cpp11::to_string(input->info()->dimension(1));
 215     _config_id += "_";
 216     _config_id += support::cpp11::to_string(input->info()->dimension(2));
 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 CLDepthwiseConvolutionLayer3x3Kernel::run(const Window &window, cl::CommandQueue &queue)
 224 {
 225     ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);
 226     ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(IKernel::window(), window);
 227
 228     // Create input window and adjust
 229     Window win_in = window;
 230     win_in.adjust(Window::DimX, -_conv_pad_left, true);
 231     win_in.adjust(Window::DimY, -_conv_pad_top, true);
 232     win_in.set_dimension_step(Window::DimX, window.x().step() * _conv_stride_x);
 233     win_in.set_dimension_step(Window::DimY, window.y().step() * _conv_stride_y);
 234
 235     Window slice_in      = win_in.first_slice_window_3D();
 236     Window slice_out     = window.first_slice_window_3D();
 237     Window slice_weights = window.first_slice_window_3D();
 238     slice_weights.set_dimension_step(Window::DimX, 0);
 239     slice_weights.set_dimension_step(Window::DimY, 0);
 240
 241     // Set biases
 242     if(_biases != nullptr)
 243     {
 244         unsigned int idx = 3 * num_arguments_per_3D_tensor();
 245         Window       slice_biases;
 246         slice_biases.use_tensor_dimensions(_biases->info()->tensor_shape());
 247         add_1D_tensor_argument(idx, _biases, slice_biases);
 248     }
 249
 250     do
 251     {
 252         unsigned int idx = 0;
 253         add_3D_tensor_argument(idx, _input, slice_in);
 254         add_3D_tensor_argument(idx, _output, slice_out);
 255         add_3D_tensor_argument(idx, _weights, slice_weights);
 256
 257         enqueue(queue, *this, slice_out, _lws_hint);
 258     }
 259     while(window.slide_window_slice_3D(slice_out) && win_in.slide_window_slice_3D(slice_in));
 260 }