src/core/GLES_COMPUTE/cs_shaders/depthwise_convolution3x3.cs

   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 layout(local_size_x = LOCAL_SIZE_X, local_size_y = LOCAL_SIZE_Y, local_size_z = LOCAL_SIZE_Z) in;
  25
  26 #include "helpers_cs.h"
  27
  28 #if defined(DATA_TYPE_FP16)
  29 precision mediump float;
  30 #endif // DATA_TYPE_FP16
  31
  32 /** This kernel performs a depthwise convolution.
  33  *
  34  * @note The data type must be passed at compile time using "#define DATA_TYPE_NAME". e.g. "#define DATA_TYPE_FP32"
  35  * @note This kernel has multiple optimized depthwise convolution options for FP16.
  36  *       The depthwise convolution option must be passed at compile time using "#define PROCESS_nX_nY_nZ" e.g. "#define PROCESS_8X_1Y_1Z"
  37  * @note The convolution stride x must be passed at compile time using "#define STRIDE_X n" e.g. "#define STRIDE_X 1"
  38  * @note In case biases will be added to the convolution "#define HAS_BIAS" has to be passed to append the final matrix with 1 in each row.
  39  *
  40  * @param[in]  src_ptr       Pointer to the source tensor. Supported data types: F16
  41  * @param[in]  src_attrs     The attributes of the source tensor
  42  * @param[out] dst_ptr       Pointer to the destination tensor. Supported data types: same as @p src_ptr
  43  * @param[in]  dst_attrs     The attributes of the destination tensor
  44  * @param[in]  weights_ptr   Pointer to the weights tensor. Supported data types: same as @p src_ptr
  45  * @param[in]  weights_attrs The attributes of the weights tensor
  46  * @param[in]  biases_ptr    Pointer to the biases tensor. Same as @p src_ptr
  47  * @param[in]  biases_attrs  The attributes of the weights tensor
  48  */
  49 SHADER_PARAMS_DECLARATION
  50 {
  51     Tensor3DAttributes src_attrs;
  52     Tensor3DAttributes dst_attrs;
  53     Tensor3DAttributes weights_attrs;
  54 #ifdef BIAS
  55     VectorAttributes biases_attrs;
  56 #endif /* BIAS */
  57 };
  58
  59 #if defined(DATA_TYPE_FP16)
  60 #if defined(PROCESS_4X_3Y_1Z)
  61 TENSOR_DECLARATION(1, srcBuffer, uvec2, src_ptr, src_shift, 3, readonly);
  62 TENSOR_DECLARATION(2, dstBuffer, uvec2, dst_ptr, dst_shift, 3, writeonly);
  63 TENSOR_DECLARATION(3, weightsBuffer, uvec2, weights_ptr, weights_shift, 3, readonly);
  64 #ifdef BIAS
  65 TENSOR_DECLARATION(4, biasesBuffer, uint, biases_ptr, biases_shift, 2, readonly);
  66 #endif /* BIAS */
  67
  68 #define LOAD_UNPACK_SWIZZLE(offset) load_unpack_swizzle_stride1(offset)
  69
  70 vec4 convolve1x3(vec4 s[3], vec4 w)
  71 {
  72     vec4 r;
  73
  74     r = s[0] * w[0] + s[1] * w[1] + s[2] * w[2];
  75
  76     return r;
  77 }
  78
  79 vec4[3] load_unpack_swizzle_stride1(uint offset)
  80 {
  81     vec4 s[2];
  82     s = VLOAD2_UNPACK8_HALF(src_ptr, offset);
  83
  84     vec4 r[3];
  85     r[0] = s[0];
  86     r[1] = vec4(s[0].yzw, s[1].x);
  87     r[2] = vec4(s[0].zw, s[1].xy);
  88
  89     return r;
  90 }
  91
  92 void main()
  93 {
  94     Tensor3DIterator src_iter     = CONVERT_TO_TENSOR3D_ITERATOR(src_attrs, src_shift);
  95     Tensor3DIterator weights_iter = CONVERT_TO_TENSOR3D_ITERATOR_NO_STEP(weights_attrs, weights_shift);
  96     Tensor3DIterator dst_iter     = CONVERT_TO_TENSOR3D_ITERATOR(dst_attrs, dst_shift);
  97
  98 #ifdef BIAS
  99     VectorIterator biases_iter = CONVERT_TO_VECTOR_ITERATOR_NO_STEP(biases_attrs, biases_shift);
 100 #endif /* BIAS */
 101
 102     vec4 pixels[3];
 103     for(int i = 0; i < 3; i++)
 104     {
 105         pixels[i] = vec4(0);
 106     }
 107
 108     uint z_index = gl_GlobalInvocationID.z;
 109     TENSOR_ITERATOR_ADVANCE_IN_BYTES(weights_iter, z_index * weights_attrs.stride_z);
 110
 111     src_iter.current_offset_in_bytes -= int((z_index - z_index / uint(DEPTH_MULTIPLIER)) * src_attrs.step_z);
 112
 113     vec4 w[3];
 114     w[0] = LOAD_UNPACK4_CURRENT_ITEM_HALF(weights_ptr, weights_iter);
 115     w[1] = LOAD_UNPACK4_HALF(weights_ptr, TENSOR3D_OFFSET(weights_iter, 0, 1, 0));
 116     w[2] = LOAD_UNPACK4_HALF(weights_ptr, TENSOR3D_OFFSET(weights_iter, 0, 2, 0));
 117
 118     vec4 s[3];
 119     vec4 r;
 120     // first line
 121     s = LOAD_UNPACK_SWIZZLE(CURRENT_ITEM_OFFSET(src_iter));
 122
 123     r = convolve1x3(s, w[0]);
 124     pixels[0] += r;
 125
 126     // second line
 127     s = LOAD_UNPACK_SWIZZLE(TENSOR3D_OFFSET(src_iter, 0, 1, 0));
 128
 129     r = convolve1x3(s, w[1]);
 130     pixels[0] += r;
 131     r = convolve1x3(s, w[0]);
 132     pixels[1] += r;
 133
 134     // third line
 135     s = LOAD_UNPACK_SWIZZLE(TENSOR3D_OFFSET(src_iter, 0, 2, 0));
 136
 137     r = convolve1x3(s, w[2]);
 138     pixels[0] += r;
 139     r = convolve1x3(s, w[1]);
 140     pixels[1] += r;
 141     r = convolve1x3(s, w[0]);
 142     pixels[2] += r;
 143
 144     // forth line
 145     s = LOAD_UNPACK_SWIZZLE(TENSOR3D_OFFSET(src_iter, 0, 3, 0));
 146
 147     r = convolve1x3(s, w[2]);
 148     pixels[1] += r;
 149     r = convolve1x3(s, w[1]);
 150     pixels[2] += r;
 151
 152     // fifth line
 153     s = LOAD_UNPACK_SWIZZLE(TENSOR3D_OFFSET(src_iter, 0, 4, 0));
 154
 155     r = convolve1x3(s, w[2]);
 156     pixels[2] += r;
 157
 158 #ifdef BIAS
 159     vec2  vec2_b;
 160     float b;
 161
 162     vec2_b = LOAD_UNPACK2_HALF(biases_ptr, VECTOR_OFFSET(biases_iter, z_index));
 163
 164     if(z_index % uint(2) == uint(0))
 165     {
 166         b = vec2_b.x;
 167     }
 168     else
 169     {
 170         b = vec2_b.y;
 171     }
 172
 173     for(int i = 0; i < 3; i++)
 174     {
 175         pixels[i] += vec4(b);
 176     }
 177 #endif /* BIAS */
 178
 179     STORE_PACK4_CURRENT_ITEM_HALF(dst_ptr, dst_iter, pixels[0]);
 180     STORE_PACK4_HALF(dst_ptr, TENSOR3D_OFFSET(dst_iter, 0, 1, 0), pixels[1]);
 181     STORE_PACK4_HALF(dst_ptr, TENSOR3D_OFFSET(dst_iter, 0, 2, 0), pixels[2]);
 182 }
 183 #elif defined(PROCESS_4X_1Y_1Z)
 184 TENSOR_DECLARATION(1, srcBuffer, uvec2, src_ptr, src_shift, 3, readonly);
 185 TENSOR_DECLARATION(2, dstBuffer, uvec2, dst_ptr, dst_shift, 3, writeonly);
 186 TENSOR_DECLARATION(3, weightsBuffer, uvec2, weights_ptr, weights_shift, 3, readonly);
 187 #ifdef BIAS
 188 TENSOR_DECLARATION(4, biasesBuffer, uint, biases_ptr, biases_shift, 2, readonly);
 189 #endif /* BIAS */
 190
 191 #if STRIDE_X == 3
 192 #define LOAD_UNPACK_SWIZZLE(offset) load_unpack_swizzle_stride3(offset)
 193 #elif STRIDE_X == 2
 194 #define LOAD_UNPACK_SWIZZLE(offset) load_unpack_swizzle_stride2(offset)
 195 #elif STRIDE_X == 1 /* STRIDE_X == 1 */
 196 #define LOAD_UNPACK_SWIZZLE(offset) load_unpack_swizzle_stride1(offset)
 197 #else /* STRIDE_X not equals 1 or 2 */
 198 #error STRIDE_X larger than 2 is not supported
 199 #endif /* STRIDE_X == 2 */
 200
 201 vec4 convolve1x3(vec4 s[3], vec4 w)
 202 {
 203     vec4 r;
 204
 205     r = s[0] * w[0] + s[1] * w[1] + s[2] * w[2];
 206
 207     return r;
 208 }
 209
 210 vec4[3] load_unpack_swizzle_stride1(uint offset)
 211 {
 212     vec4 s[2];
 213     s = VLOAD2_UNPACK8_HALF(src_ptr, offset);
 214
 215     vec4 r[3];
 216     r[0] = s[0];
 217     r[1] = vec4(s[0].yzw, s[1].x);
 218     r[2] = vec4(s[0].zw, s[1].xy);
 219
 220     return r;
 221 }
 222
 223 vec4[3] load_unpack_swizzle_stride2(uint offset)
 224 {
 225     vec4 s[3];
 226     s[0] = LOAD_UNPACK4_HALF(src_ptr, offset);
 227     s[1] = LOAD_UNPACK4_HALF(src_ptr, offset + uint(1));
 228     s[2] = LOAD_UNPACK4_HALF(src_ptr, offset + uint(2));
 229
 230     vec4 r[3];
 231     r[0] = vec4(s[0].xz, s[1].xz);
 232     r[1] = vec4(s[0].yw, s[1].yw);
 233     r[2] = vec4(s[0].z, s[1].xz, s[2].x);
 234
 235     return r;
 236 }
 237
 238 vec4[3] load_unpack_swizzle_stride3(uint offset)
 239 {
 240     vec4 s[3];
 241     s[0] = LOAD_UNPACK4_HALF(src_ptr, offset);
 242     s[1] = LOAD_UNPACK4_HALF(src_ptr, offset + uint(1));
 243     s[2] = LOAD_UNPACK4_HALF(src_ptr, offset + uint(2));
 244
 245     vec4 r[3];
 246     r[0] = vec4(s[0].xw, s[1].z, s[2].y);
 247     r[1] = vec4(s[0].y, s[1].xw, s[2].z);
 248     r[2] = vec4(s[0].z, s[1].y, s[2].xw);
 249
 250     return r;
 251 }
 252
 253 void main()
 254 {
 255     Tensor3DIterator src_iter     = CONVERT_TO_TENSOR3D_ITERATOR(src_attrs, src_shift);
 256     Tensor3DIterator weights_iter = CONVERT_TO_TENSOR3D_ITERATOR_NO_STEP(weights_attrs, weights_shift);
 257     Tensor3DIterator dst_iter     = CONVERT_TO_TENSOR3D_ITERATOR(dst_attrs, dst_shift);
 258
 259 #ifdef BIAS
 260     VectorIterator   biases_iter  = CONVERT_TO_VECTOR_ITERATOR_NO_STEP(biases_attrs, biases_shift);
 261 #endif /* BIAS */
 262
 263     vec4 pixels = vec4(0.f);
 264
 265     uint z_index = gl_GlobalInvocationID.z;
 266     TENSOR_ITERATOR_ADVANCE_IN_BYTES(weights_iter, z_index * weights_attrs.stride_z);
 267
 268     src_iter.current_offset_in_bytes -= int((z_index - z_index / uint(DEPTH_MULTIPLIER)) * src_attrs.step_z);
 269
 270     vec4 w[3];
 271     w[0] = LOAD_UNPACK4_CURRENT_ITEM_HALF(weights_ptr, weights_iter);
 272     w[1] = LOAD_UNPACK4_HALF(weights_ptr, TENSOR3D_OFFSET(weights_iter, 0, 1, 0));
 273     w[2] = LOAD_UNPACK4_HALF(weights_ptr, TENSOR3D_OFFSET(weights_iter, 0, 2, 0));
 274
 275     vec4 s[3];
 276     vec4 r;
 277     // first line
 278     s = LOAD_UNPACK_SWIZZLE(CURRENT_ITEM_OFFSET(src_iter));
 279
 280     r = convolve1x3(s, w[0]);
 281     pixels += r;
 282
 283     // second line
 284     s = LOAD_UNPACK_SWIZZLE(TENSOR3D_OFFSET(src_iter, 0, 1, 0));
 285
 286     r = convolve1x3(s, w[1]);
 287     pixels += r;
 288
 289     // third line
 290     s = LOAD_UNPACK_SWIZZLE(TENSOR3D_OFFSET(src_iter, 0, 2, 0));
 291
 292     r = convolve1x3(s, w[2]);
 293     pixels += r;
 294
 295 #ifdef BIAS
 296     vec2  vec2_b;
 297     float b;
 298
 299     vec2_b = LOAD_UNPACK2_HALF(biases_ptr, VECTOR_OFFSET(biases_iter, z_index));
 300
 301     if(z_index % uint(2) == uint(0))
 302     {
 303         b = vec2_b.x;
 304     }
 305     else
 306     {
 307         b = vec2_b.y;
 308     }
 309
 310     pixels += vec4(b);
 311 #endif /* BIAS */
 312
 313     STORE_PACK4_CURRENT_ITEM_HALF(dst_ptr, dst_iter, pixels);
 314 }
 315 #endif /* PROCESS_4X_3Y_1Z */
 316 #endif /* DATA_TYPE_FP16 */