Download modules/dnn/src/opencl/slice.cl from tgollogly/test: direct link, hf CLI and curl.
- Browser
- Download file 7.52 kB
-
https://huggingface.co/tgollogly/test/resolve/main/modules/dnn/src/opencl/slice.cl
- Command line
-
hf download hf://tgollogly/test/modules/dnn/src/opencl/slice.cl
-
curl -L -o slice.cl https://huggingface.co/tgollogly/test/resolve/main/modules/dnn/src/opencl/slice.cl
7.52 kB
| // This file is part of OpenCV project. | |
| // It is subject to the license terms in the LICENSE file found in the top-level directory | |
| // of this distribution and at http://opencv.org/license.html. | |
| // Copyright (C) 2020, Intel Corporation, all rights reserved. | |
| // Third party copyrights are property of their respective owners. | |
| /* | |
| Specialization constants: | |
| - WSZ: size of OpenCL local group | |
| - DIMS: number of working dimensions | |
| - ELEMSIZE: element size in bytes | |
| - DST_SZ_<i>: dst sizes | |
| - SRC_START_<i>: src index shift (slice .start value) | |
| - SRC_STEP_<i>: src steps (bytes) | |
| - DST_STEP_<i>: dst steps (bytes), derived from DST_SZ_<i> and ELEMSIZE | |
| - BLOCK_DIMS: number of dims for copy block (argmax(count(SRC_STEP_<i> != DST_STEP_<i>) <= 1)) | |
| - BLOCK_DIMS_CONTIGUOUS (<= BLOCK_DIMS): SRC_STEP_<i> == DST_STEP_<i> for i in [0, BLOCK_DIMS_CONTIGUOUS) | |
| derived specialization constants: | |
| - BLOCK_SIZE: ELEMSIZE * mul(DST_SZ_<i>) for i in [0, BLOCK_DIMS) | |
| - USE_COPY_1D iff BLOCK_DIMS == BLOCK_DIMS_CONTIGUOUS | |
| - BLOCK_COLS: | |
| * with USE_COPY_1D: BLOCK_SIZE | |
| * w/o USE_COPY_1D: ELEMSIZE * mul(DST_SZ_<i>) for i in [0, BLOCK_DIMS_CONTIGUOUS) | |
| - BLOCK_ROWS: | |
| * with USE_COPY_1D: N/A | |
| * w/o USE_COPY_1D: ELEMSIZE * mul(DST_SZ_<i>) for i in [BLOCK_DIMS_CONTIGUOUS, BLOCK_DIMS) | |
| - BLOCK_SRC_STRIDE: | |
| * with USE_COPY_1D: N/A | |
| * w/o USE_COPY_1D: ELEMSIZE * mul(SRC_STEP_<i>) for i in [0, BLOCK_DIMS_CONTIGUOUS) | |
| Note: SZ, STEP values are in reversed order than OpenCV Mat: | |
| - NCHW SZ: [cols, rows, channels, batch] | |
| - NCHW STEP: [elemsize, cols * elemsize, rows * cols * elemsize, ...] (DIMS+1 value) | |
| */ | |
| /* | |
| local: <WSZ, 1, 1> | |
| global: <WSZ, number_of_copy_blocks, 1> | |
| */ | |
| __attribute__((reqd_work_group_size(WSZ, 1, 1))) | |
| __kernel void | |
| CONCAT(slice_, SLICE_KERNEL_SUFFIX)( | |
| __global const uchar* src0, | |
| __global uchar* dst0 | |
| ) | |
| { | |
| uint block_id = get_global_id(1); | |
| uint dst_offset0 = block_id * BLOCK_SIZE; | |
| uint src_offset0 = 0; | |
| { // calculate src_offset0 | |
| /* | |
| if (get_global_id(0) == 0 && get_global_id(1) == 0) \ | |
| printf("(%d, %d): @%d src_offset0=%d idx_dim=%d block_id=%d\n", \ | |
| get_global_id(0), get_global_id(1), \ | |
| dim, src_offset0, CONCAT(idx_, dim), block_id \ | |
| ); | |
| */ | |
| uint idx_4 = 0; | |
| CALC_SRC_INDEX(4) | |
| UPDATE_SRC_OFFSET(4) | |
| uint idx_3 = 0; | |
| CALC_SRC_INDEX(3) | |
| UPDATE_SRC_OFFSET(3) | |
| uint idx_2 = 0; | |
| CALC_SRC_INDEX(2) | |
| UPDATE_SRC_OFFSET(2) | |
| uint idx_1 = 0; | |
| CALC_SRC_INDEX(1) | |
| UPDATE_SRC_OFFSET(1) | |
| uint idx_0 = 0; | |
| UPDATE_SRC_OFFSET(0) | |
| /* | |
| if (get_global_id(0) == 0) | |
| printf("(%d, %d): src_offset0=%d dst_offset0=%d\n", | |
| get_global_id(0), get_global_id(1), | |
| src_offset0, dst_offset0 | |
| ); | |
| */ | |
| } // calculate src_offset0 | |
| { // copy_block_1d | |
| __global const uchar* src = src0 + src_offset0; | |
| __global uchar* dst = dst0 + dst_offset0; | |
| uint processed = 0; | |
| { | |
| // uchar16 x 4rows per iteration | |
| uint i = get_local_id(0) * 16; // uchar16 | |
| while (i < BLOCK_COLS_X16 * 16) | |
| { | |
| uint4 idx0 = (uint4)i; | |
| uint4 idx = idx0 + (uint4)(0, 16 * WSZ, 32 * WSZ, 48 * WSZ); | |
| idx = select(idx0, idx, idx < (BLOCK_COLS_X16 * 16)); | |
| uchar16 a0 = vload16(0, src + idx.s0); | |
| uchar16 a1 = vload16(0, src + idx.s1); | |
| uchar16 a2 = vload16(0, src + idx.s2); | |
| uchar16 a3 = vload16(0, src + idx.s3); | |
| vstore16(a0, 0, dst + idx.s0); | |
| vstore16(a1, 0, dst + idx.s1); | |
| vstore16(a2, 0, dst + idx.s2); | |
| vstore16(a3, 0, dst + idx.s3); | |
| i += WSZ * 16 * 4; | |
| } | |
| processed = BLOCK_COLS_X16 * 16; | |
| } | |
| { | |
| // uchar4 x 4rows per iteration | |
| uint i = get_local_id(0) * 4 + processed; // uchar4 | |
| while (i < BLOCK_COLS_X4 * 4) | |
| { | |
| uint4 idx0 = (uint4)i; | |
| uint4 idx = idx0 + (uint4)(0, 4 * WSZ, 8 * WSZ, 12 * WSZ); | |
| idx = select(idx0, idx, idx < (BLOCK_COLS_X4 * 4)); | |
| uchar4 a0 = vload4(0, src + idx.s0); | |
| uchar4 a1 = vload4(0, src + idx.s1); | |
| uchar4 a2 = vload4(0, src + idx.s2); | |
| uchar4 a3 = vload4(0, src + idx.s3); | |
| vstore4(a0, 0, dst + idx.s0); | |
| vstore4(a1, 0, dst + idx.s1); | |
| vstore4(a2, 0, dst + idx.s2); | |
| vstore4(a3, 0, dst + idx.s3); | |
| i += WSZ * 4 * 4; | |
| } | |
| processed = BLOCK_COLS_X4 * 4; | |
| } | |
| { | |
| uint i = get_local_id(0) + processed; | |
| while (i < BLOCK_COLS) | |
| { | |
| uchar a0 = src[i]; | |
| dst[i] = a0; | |
| i += WSZ; | |
| } | |
| } | |
| } // copy_block_1d | |
| { // copy_block_2d | |
| __global const uchar* src = src0 + src_offset0; | |
| __global uchar* dst = dst0 + dst_offset0; | |
| uint i = get_local_id(0) * 4; | |
| while (i < BLOCK_SIZE_FILL_X4) | |
| { | |
| int row = i / BLOCK_COLS_FILL_X4; | |
| int col = i % BLOCK_COLS_FILL_X4; | |
| uint src_offset = row * BLOCK_SRC_STRIDE + col; | |
| uint dst_offset = i; | |
| uint dst_offset = row * BLOCK_COLS + col; | |
| if (col <= BLOCK_COLS - 4) | |
| { | |
| uchar4 a = vload4(0, src + src_offset); | |
| vstore4(a, 0, dst + dst_offset); | |
| } | |
| else | |
| { | |
| /* non-optimized reference code | |
| while (col < BLOCK_COLS) | |
| { | |
| uchar a = src[src_offset]; | |
| dst[dst_offset] = a; | |
| col++; | |
| src_offset++; | |
| dst_offset++; | |
| } | |
| */ | |
| uint4 shift = (uint4)(0, 1, 2, 3); | |
| shift = select((uint4)0, shift, col + shift < BLOCK_COLS); | |
| dst[dst_offset + shift.s0] = src[src_offset + shift.s0]; | |
| dst[dst_offset + shift.s1] = src[src_offset + shift.s1]; | |
| dst[dst_offset + shift.s2] = src[src_offset + shift.s2]; | |
| } | |
| i += WSZ * 4; | |
| } | |
| } // copy_block_2d | |
| } | |