/* All 16 bytes aligned, fast and easy one. */
if((cb % 16 == 0) && (src_offset % 16 == 0) && (dst_offset % 16 == 0)) {
extern char cl_internal_copy_buf_align16_str[];
- extern int cl_internal_copy_buf_align16_str_size;
+ extern size_t cl_internal_copy_buf_align16_str_size;
ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_COPY_BUFFER_ALIGN16,
cl_internal_copy_buf_align16_str, (size_t)cl_internal_copy_buf_align16_str_size, NULL);
aligned = 1;
} else if ((cb % 4 == 0) && (src_offset % 4 == 0) && (dst_offset % 4 == 0)) { /* all Dword aligned.*/
extern char cl_internal_copy_buf_align4_str[];
- extern int cl_internal_copy_buf_align4_str_size;
+ extern size_t cl_internal_copy_buf_align4_str_size;
ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_COPY_BUFFER_ALIGN4,
cl_internal_copy_buf_align4_str, (size_t)cl_internal_copy_buf_align4_str_size, NULL);
/* Src and dst has the same unaligned offset, just handle the
header and tail. */
extern char cl_internal_copy_buf_unalign_same_offset_str[];
- extern int cl_internal_copy_buf_unalign_same_offset_str_size;
+ extern size_t cl_internal_copy_buf_unalign_same_offset_str_size;
ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_COPY_BUFFER_UNALIGN_SAME_OFFSET,
cl_internal_copy_buf_unalign_same_offset_str,
/* Dst's offset < Src's offset, so one dst dword need two sequential src dwords to fill it. */
if (dst_offset % 4 < src_offset % 4) {
extern char cl_internal_copy_buf_unalign_dst_offset_str[];
- extern int cl_internal_copy_buf_unalign_dst_offset_str_size;
+ extern size_t cl_internal_copy_buf_unalign_dst_offset_str_size;
int align_diff = src_offset % 4 - dst_offset % 4;
unsigned int dw_mask = masks[align_diff];
/* Dst's offset > Src's offset, so one dst dword need two sequential src - and src to fill it. */
if (dst_offset % 4 > src_offset % 4) {
extern char cl_internal_copy_buf_unalign_src_offset_str[];
- extern int cl_internal_copy_buf_unalign_src_offset_str_size;
+ extern size_t cl_internal_copy_buf_unalign_src_offset_str_size;
int align_diff = dst_offset % 4 - src_offset % 4;
unsigned int dw_mask = masks[4 - align_diff];
if(src_image->image_type == CL_MEM_OBJECT_IMAGE1D) {
extern char cl_internal_fill_image_1d_str[];
- extern int cl_internal_fill_image_1d_str_size;
+ extern size_t cl_internal_fill_image_1d_str_size;
ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_FILL_IMAGE_1D,
cl_internal_fill_image_1d_str, (size_t)cl_internal_fill_image_1d_str_size, NULL);
}else if(src_image->image_type == CL_MEM_OBJECT_IMAGE1D_ARRAY) {
extern char cl_internal_fill_image_1d_array_str[];
- extern int cl_internal_fill_image_1d_array_str_size;
+ extern size_t cl_internal_fill_image_1d_array_str_size;
ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_FILL_IMAGE_1D_ARRAY,
cl_internal_fill_image_1d_array_str, (size_t)cl_internal_fill_image_1d_array_str_size, NULL);
}else if(src_image->image_type == CL_MEM_OBJECT_IMAGE2D) {
extern char cl_internal_fill_image_2d_str[];
- extern int cl_internal_fill_image_2d_str_size;
+ extern size_t cl_internal_fill_image_2d_str_size;
ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_FILL_IMAGE_2D,
cl_internal_fill_image_2d_str, (size_t)cl_internal_fill_image_2d_str_size, NULL);
}else if(src_image->image_type == CL_MEM_OBJECT_IMAGE2D_ARRAY) {
extern char cl_internal_fill_image_2d_array_str[];
- extern int cl_internal_fill_image_2d_array_str_size;
+ extern size_t cl_internal_fill_image_2d_array_str_size;
ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_FILL_IMAGE_2D_ARRAY,
cl_internal_fill_image_2d_array_str, (size_t)cl_internal_fill_image_2d_array_str_size, NULL);
}else if(src_image->image_type == CL_MEM_OBJECT_IMAGE3D) {
extern char cl_internal_fill_image_3d_str[];
- extern int cl_internal_fill_image_3d_str_size;
+ extern size_t cl_internal_fill_image_3d_str_size;
ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_FILL_IMAGE_3D,
cl_internal_fill_image_3d_str, (size_t)cl_internal_fill_image_3d_str_size, NULL);
/* 128 is according to pattern of double16, but double works not very
well on some platform. We use two float16 to handle this. */
extern char cl_internal_fill_buf_align128_str[];
- extern int cl_internal_fill_buf_align128_str_size;
+ extern size_t cl_internal_fill_buf_align128_str_size;
ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_FILL_BUFFER_ALIGN128,
cl_internal_fill_buf_align128_str, (size_t)cl_internal_fill_buf_align128_str_size, NULL);
size = size / 2;
} else if (pattern_size % 8 == 0) { /* Handle the 8 16 32 64 cases here. */
extern char cl_internal_fill_buf_align8_str[];
- extern int cl_internal_fill_buf_align8_str_size;
+ extern size_t cl_internal_fill_buf_align8_str_size;
int order = ffs(pattern_size / 8) - 1;
ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_FILL_BUFFER_ALIGN8_8 + order,
cl_internal_fill_buf_align8_str, (size_t)cl_internal_fill_buf_align8_str_size, NULL);
} else if (pattern_size == 4) {
extern char cl_internal_fill_buf_align4_str[];
- extern int cl_internal_fill_buf_align4_str_size;
+ extern size_t cl_internal_fill_buf_align4_str_size;
ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_FILL_BUFFER_ALIGN4,
cl_internal_fill_buf_align4_str, (size_t)cl_internal_fill_buf_align4_str_size, NULL);
the pattern with the pattern duplication fill in. */
assert(pattern_size == 1 || pattern_size == 2);
extern char cl_internal_fill_buf_align4_str[];
- extern int cl_internal_fill_buf_align4_str_size;
+ extern size_t cl_internal_fill_buf_align4_str_size;
if (pattern_size == 2) {
memcpy(pattern_comb, pattern, sizeof(char)*2);
//functions. This depend on the usage but now we just use aligned 1 and 2.
else if (pattern_size == 2) {
extern char cl_internal_fill_buf_align2_str[];
- extern int cl_internal_fill_buf_align2_str_size;
+ extern size_t cl_internal_fill_buf_align2_str_size;
ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_FILL_BUFFER_ALIGN2,
cl_internal_fill_buf_align2_str, (size_t)cl_internal_fill_buf_align2_str_size, NULL);
} else if (pattern_size == 1) {
extern char cl_internal_fill_buf_unalign_str[];
- extern int cl_internal_fill_buf_unalign_str_size;
+ extern size_t cl_internal_fill_buf_unalign_str_size;
ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_FILL_BUFFER_UNALIGN,
cl_internal_fill_buf_unalign_str, (size_t)cl_internal_fill_buf_unalign_str_size, NULL);
} else
/* setup the kernel and run. */
extern char cl_internal_copy_buf_rect_str[];
- extern int cl_internal_copy_buf_rect_str_size;
+ extern size_t cl_internal_copy_buf_rect_str_size;
ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_COPY_BUFFER_RECT,
cl_internal_copy_buf_rect_str, (size_t)cl_internal_copy_buf_rect_str_size, NULL);
if(src_image->image_type == CL_MEM_OBJECT_IMAGE1D) {
if(dst_image->image_type == CL_MEM_OBJECT_IMAGE1D) {
extern char cl_internal_copy_image_1d_to_1d_str[];
- extern int cl_internal_copy_image_1d_to_1d_str_size;
+ extern size_t cl_internal_copy_image_1d_to_1d_str_size;
ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_COPY_IMAGE_1D_TO_1D,
cl_internal_copy_image_1d_to_1d_str, (size_t)cl_internal_copy_image_1d_to_1d_str_size, NULL);
} else if(src_image->image_type == CL_MEM_OBJECT_IMAGE2D) {
if(dst_image->image_type == CL_MEM_OBJECT_IMAGE2D) {
extern char cl_internal_copy_image_2d_to_2d_str[];
- extern int cl_internal_copy_image_2d_to_2d_str_size;
+ extern size_t cl_internal_copy_image_2d_to_2d_str_size;
ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_COPY_IMAGE_2D_TO_2D,
cl_internal_copy_image_2d_to_2d_str, (size_t)cl_internal_copy_image_2d_to_2d_str_size, NULL);
} else if(dst_image->image_type == CL_MEM_OBJECT_IMAGE3D) {
extern char cl_internal_copy_image_2d_to_3d_str[];
- extern int cl_internal_copy_image_2d_to_3d_str_size;
+ extern size_t cl_internal_copy_image_2d_to_3d_str_size;
ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_COPY_IMAGE_2D_TO_3D,
cl_internal_copy_image_2d_to_3d_str, (size_t)cl_internal_copy_image_2d_to_3d_str_size, NULL);
} else if(src_image->image_type == CL_MEM_OBJECT_IMAGE3D) {
if(dst_image->image_type == CL_MEM_OBJECT_IMAGE2D) {
extern char cl_internal_copy_image_3d_to_2d_str[];
- extern int cl_internal_copy_image_3d_to_2d_str_size;
+ extern size_t cl_internal_copy_image_3d_to_2d_str_size;
ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_COPY_IMAGE_3D_TO_2D,
cl_internal_copy_image_3d_to_2d_str, (size_t)cl_internal_copy_image_3d_to_2d_str_size, NULL);
} else if(dst_image->image_type == CL_MEM_OBJECT_IMAGE3D) {
extern char cl_internal_copy_image_3d_to_3d_str[];
- extern int cl_internal_copy_image_3d_to_3d_str_size;
+ extern size_t cl_internal_copy_image_3d_to_3d_str_size;
ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_COPY_IMAGE_3D_TO_3D,
cl_internal_copy_image_3d_to_3d_str, (size_t)cl_internal_copy_image_3d_to_3d_str_size, NULL);
/* setup the kernel and run. */
if(image->image_type == CL_MEM_OBJECT_IMAGE2D) {
extern char cl_internal_copy_image_2d_to_buffer_str[];
- extern int cl_internal_copy_image_2d_to_buffer_str_size;
+ extern size_t cl_internal_copy_image_2d_to_buffer_str_size;
ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_COPY_IMAGE_2D_TO_BUFFER,
cl_internal_copy_image_2d_to_buffer_str, (size_t)cl_internal_copy_image_2d_to_buffer_str_size, NULL);
}else if(image->image_type == CL_MEM_OBJECT_IMAGE3D) {
extern char cl_internal_copy_image_3d_to_buffer_str[];
- extern int cl_internal_copy_image_3d_to_buffer_str_size;
+ extern size_t cl_internal_copy_image_3d_to_buffer_str_size;
ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_COPY_IMAGE_3D_TO_BUFFER,
cl_internal_copy_image_3d_to_buffer_str, (size_t)cl_internal_copy_image_3d_to_buffer_str_size, NULL);
/* setup the kernel and run. */
if(image->image_type == CL_MEM_OBJECT_IMAGE2D) {
extern char cl_internal_copy_buffer_to_image_2d_str[];
- extern int cl_internal_copy_buffer_to_image_2d_str_size;
+ extern size_t cl_internal_copy_buffer_to_image_2d_str_size;
ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_COPY_BUFFER_TO_IMAGE_2D,
cl_internal_copy_buffer_to_image_2d_str, (size_t)cl_internal_copy_buffer_to_image_2d_str_size, NULL);
}else if(image->image_type == CL_MEM_OBJECT_IMAGE3D) {
extern char cl_internal_copy_buffer_to_image_3d_str[];
- extern int cl_internal_copy_buffer_to_image_3d_str_size;
+ extern size_t cl_internal_copy_buffer_to_image_3d_str_size;
ker = cl_context_get_static_kernel_from_bin(queue->ctx, CL_ENQUEUE_COPY_BUFFER_TO_IMAGE_3D,
cl_internal_copy_buffer_to_image_3d_str, (size_t)cl_internal_copy_buffer_to_image_3d_str_size, NULL);