[Beignet] [PATCH v2] gbe_bin_generator: fix the incorrect type of cl_internal_built_in_kernel_str_size.
Zhigang Gong
zhigang.gong at intel.com
Wed Jun 25 18:26:42 PDT 2014
We should define it as size_t.
v2:
correct some extern definitions in cl_mem.c.
Signed-off-by: Zhigang Gong <zhigang.gong at intel.com>
---
backend/src/gbe_bin_generater.cpp | 3 ++-
src/cl_mem.c | 52 +++++++++++++++++++--------------------
src/cl_program.c | 2 +-
3 files changed, 29 insertions(+), 28 deletions(-)
diff --git a/backend/src/gbe_bin_generater.cpp b/backend/src/gbe_bin_generater.cpp
index 2627673..925ba93 100644
--- a/backend/src/gbe_bin_generater.cpp
+++ b/backend/src/gbe_bin_generater.cpp
@@ -177,6 +177,7 @@ void program_build_instance::serialize_program(void) throw(int)
if (last_slash != string::npos && last_dot != string::npos)
array_name = bin_path.substr(last_slash + 1, last_dot - 1 - last_slash);
+ ofs << "#include <stddef.h>" << "\n";
ofs << "char " << array_name << "[] = {" << "\n";
sz = gbe_prog->serializeToBin(oss);
@@ -194,7 +195,7 @@ void program_build_instance::serialize_program(void) throw(int)
ofs << "};\n";
string array_size = array_name + "_size";
- ofs << "int " << array_size << " = " << sz << ";" << "\n";
+ ofs << "size_t " << array_size << " = " << sz << ";" << "\n";
} else {
OUTF_UPDATE_SZ(header);
OUTF_UPDATE_SZ(header);
diff --git a/src/cl_mem.c b/src/cl_mem.c
index 05ca9f1..ff128af 100644
--- a/src/cl_mem.c
+++ b/src/cl_mem.c
@@ -1077,7 +1077,7 @@ cl_mem_copy(cl_command_queue queue, cl_mem src_buf, cl_mem dst_buf,
/* 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);
@@ -1085,7 +1085,7 @@ cl_mem_copy(cl_command_queue queue, cl_mem src_buf, cl_mem dst_buf,
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);
@@ -1132,7 +1132,7 @@ cl_mem_copy(cl_command_queue queue, cl_mem src_buf, cl_mem dst_buf,
/* 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,
@@ -1155,7 +1155,7 @@ cl_mem_copy(cl_command_queue queue, cl_mem src_buf, cl_mem dst_buf,
/* 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];
@@ -1184,7 +1184,7 @@ cl_mem_copy(cl_command_queue queue, cl_mem src_buf, cl_mem dst_buf,
/* 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];
@@ -1233,31 +1233,31 @@ cl_image_fill(cl_command_queue queue, const void * pattern, struct _cl_mem_image
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);
@@ -1304,7 +1304,7 @@ cl_mem_fill(cl_command_queue queue, const void * pattern, size_t pattern_size,
/* 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);
@@ -1314,14 +1314,14 @@ cl_mem_fill(cl_command_queue queue, const void * pattern, size_t pattern_size,
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);
@@ -1330,7 +1330,7 @@ cl_mem_fill(cl_command_queue queue, const void * pattern, size_t pattern_size,
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);
@@ -1349,12 +1349,12 @@ cl_mem_fill(cl_command_queue queue, const void * pattern, size_t pattern_size,
//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
@@ -1406,7 +1406,7 @@ cl_mem_copy_buffer_rect(cl_command_queue queue, cl_mem src_buf, cl_mem dst_buf,
/* 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);
@@ -1478,7 +1478,7 @@ cl_mem_kernel_copy_image(cl_command_queue queue, struct _cl_mem_image* src_image
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);
@@ -1486,13 +1486,13 @@ cl_mem_kernel_copy_image(cl_command_queue queue, struct _cl_mem_image* src_image
} 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);
@@ -1522,13 +1522,13 @@ cl_mem_kernel_copy_image(cl_command_queue queue, struct _cl_mem_image* src_image
} 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);
@@ -1600,13 +1600,13 @@ cl_mem_copy_image_to_buffer(cl_command_queue queue, struct _cl_mem_image* image,
/* 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);
@@ -1674,13 +1674,13 @@ cl_mem_copy_buffer_to_image(cl_command_queue queue, cl_mem buffer, struct _cl_me
/* 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);
diff --git a/src/cl_program.c b/src/cl_program.c
index 7888a8f..d7e9ae7 100644
--- a/src/cl_program.c
+++ b/src/cl_program.c
@@ -268,7 +268,7 @@ cl_program_create_with_built_in_kernles(cl_context ctx,
INVALID_DEVICE_IF (devices[0] != ctx->device);
extern char cl_internal_built_in_kernel_str[];
- extern int cl_internal_built_in_kernel_str_size;
+ extern size_t cl_internal_built_in_kernel_str_size;
char* p_built_in_kernel_str =cl_internal_built_in_kernel_str;
cl_int binary_status = CL_SUCCESS;
--
1.8.3.2
More information about the Beignet
mailing list