there are weired issues about stdc++ when dlopen .so file with flag RTLD_DEEPBIND, remove the flag by renaming the function pointer names. The new names in runtime begin with interp_*, meaning that they finally go into libgbeinterp.so to interpret the meta data of binary kernel.
Signed-off-by: Guo Yejun <[email protected]> --- src/cl_command_queue.c | 16 ++-- src/cl_command_queue_gen7.c | 60 ++++++------- src/cl_device_id.c | 2 +- src/cl_gbe_loader.cpp | 206 ++++++++++++++++++++++---------------------- src/cl_gbe_loader.h | 37 +++++++- src/cl_kernel.c | 36 ++++---- src/cl_program.c | 18 ++-- src/intel/intel_driver.c | 2 +- 8 files changed, 206 insertions(+), 171 deletions(-) diff --git a/src/cl_command_queue.c b/src/cl_command_queue.c index 618be65..15b0ead 100644 --- a/src/cl_command_queue.c +++ b/src/cl_command_queue.c @@ -130,7 +130,7 @@ cl_command_queue_bind_image(cl_command_queue queue, cl_kernel k) for (i = 0; i < k->image_sz; i++) { int id = k->images[i].arg_idx; struct _cl_mem_image *image; - assert(gbe_kernel_get_arg_type(k->opaque, id) == GBE_ARG_IMAGE); + assert(interp_kernel_get_arg_type(k->opaque, id) == GBE_ARG_IMAGE); image = cl_mem_image(k->args[id].mem); set_image_info(k->curbe, &k->images[i], image); cl_gpgpu_bind_image(gpgpu, k->images[i].idx, image->base.bo, image->offset, @@ -151,10 +151,10 @@ cl_command_queue_bind_surface(cl_command_queue queue, cl_kernel k) enum gbe_arg_type arg_type; /* kind of argument */ for (i = 0; i < k->arg_n; ++i) { uint32_t offset; // location of the address in the curbe - arg_type = gbe_kernel_get_arg_type(k->opaque, i); + arg_type = interp_kernel_get_arg_type(k->opaque, i); if (arg_type != GBE_ARG_GLOBAL_PTR || !k->args[i].mem) continue; - offset = gbe_kernel_get_curbe_offset(k->opaque, GBE_CURBE_KERNEL_ARGUMENT, i); + offset = interp_kernel_get_curbe_offset(k->opaque, GBE_CURBE_KERNEL_ARGUMENT, i); if (k->args[i].mem->type == CL_MEM_SUBBUFFER_TYPE) { struct _cl_mem_buffer* buffer = (struct _cl_mem_buffer*)k->args[i].mem; cl_gpgpu_bind_buf(gpgpu, k->args[i].mem->bo, offset, buffer->sub_offset, cl_gpgpu_get_cache_ctrl()); @@ -208,7 +208,7 @@ cl_fulsim_dump_all_surfaces(cl_command_queue queue, cl_kernel k) /* Bind user defined surface */ for (i = 0; i < k->arg_n; ++i) { size_t chunk_n, chunk_remainder; - if (gbe_kernel_get_arg_type(k->opaque, i) != GBE_ARG_GLOBAL_PTR) + if (interp_kernel_get_arg_type(k->opaque, i) != GBE_ARG_GLOBAL_PTR) continue; mem = (cl_mem) k->args[i].mem; CHECK_MEM(mem); @@ -316,7 +316,7 @@ cl_fulsim_read_all_surfaces(cl_command_queue queue, cl_kernel k) int i, curr = 0; /* Bind user defined surface */ for (i = 0; i < k->arg_n; ++i) { - if (gbe_kernel_get_arg_type(k->opaque, i) != GBE_ARG_GLOBAL_PTR) + if (interp_kernel_get_arg_type(k->opaque, i) != GBE_ARG_GLOBAL_PTR) continue; mem = (cl_mem) k->args[i].mem; CHECK_MEM(mem); @@ -425,14 +425,14 @@ cl_command_queue_flush(cl_command_queue queue) cl_gpgpu_flush(gpgpu); - if (printf_info && gbe_get_printf_num(printf_info)) { + if (printf_info && interp_get_printf_num(printf_info)) { void *index_addr = cl_gpgpu_map_printf_buffer(gpgpu, 0); void *buf_addr = cl_gpgpu_map_printf_buffer(gpgpu, 1); - gbe_output_printf(printf_info, index_addr, buf_addr, global_wk_sz[0], + interp_output_printf(printf_info, index_addr, buf_addr, global_wk_sz[0], global_wk_sz[1], global_wk_sz[2]); cl_gpgpu_unmap_printf_buffer(gpgpu, 0); cl_gpgpu_unmap_printf_buffer(gpgpu, 1); - gbe_release_printf_info(printf_info); + interp_release_printf_info(printf_info); global_wk_sz[0] = global_wk_sz[1] = global_wk_sz[2] = 0; cl_gpgpu_set_printf_info(gpgpu, NULL, global_wk_sz); } diff --git a/src/cl_command_queue_gen7.c b/src/cl_command_queue_gen7.c index 9680535..2223f4f 100644 --- a/src/cl_command_queue_gen7.c +++ b/src/cl_command_queue_gen7.c @@ -50,10 +50,10 @@ cl_set_varying_payload(const cl_kernel ker, int32_t id_offset[3], ip_offset; cl_int err = CL_SUCCESS; - id_offset[0] = gbe_kernel_get_curbe_offset(ker->opaque, GBE_CURBE_LOCAL_ID_X, 0); - id_offset[1] = gbe_kernel_get_curbe_offset(ker->opaque, GBE_CURBE_LOCAL_ID_Y, 0); - id_offset[2] = gbe_kernel_get_curbe_offset(ker->opaque, GBE_CURBE_LOCAL_ID_Z, 0); - ip_offset = gbe_kernel_get_curbe_offset(ker->opaque, GBE_CURBE_BLOCK_IP, 0); + id_offset[0] = interp_kernel_get_curbe_offset(ker->opaque, GBE_CURBE_LOCAL_ID_X, 0); + id_offset[1] = interp_kernel_get_curbe_offset(ker->opaque, GBE_CURBE_LOCAL_ID_Y, 0); + id_offset[2] = interp_kernel_get_curbe_offset(ker->opaque, GBE_CURBE_LOCAL_ID_Z, 0); + ip_offset = interp_kernel_get_curbe_offset(ker->opaque, GBE_CURBE_BLOCK_IP, 0); assert(id_offset[0] >= 0 && id_offset[1] >= 0 && id_offset[2] >= 0 && @@ -107,16 +107,16 @@ cl_upload_constant_buffer(cl_command_queue queue, cl_kernel ker) size_t offset = 0; uint32_t raw_size = 0, aligned_size =0; gbe_program prog = ker->program->opaque; - const int32_t arg_n = gbe_kernel_get_arg_num(ker->opaque); - size_t global_const_size = gbe_program_get_global_constant_size(prog); + const int32_t arg_n = interp_kernel_get_arg_num(ker->opaque); + size_t global_const_size = interp_program_get_global_constant_size(prog); aligned_size = raw_size = global_const_size; /* Reserve 8 bytes to get rid of 0 address */ if(global_const_size == 0) aligned_size = 8; for (arg = 0; arg < arg_n; ++arg) { - const enum gbe_arg_type type = gbe_kernel_get_arg_type(ker->opaque, arg); + const enum gbe_arg_type type = interp_kernel_get_arg_type(ker->opaque, arg); if (type == GBE_ARG_CONSTANT_PTR && ker->args[arg].mem) { - uint32_t alignment = gbe_kernel_get_arg_align(ker->opaque, arg); + uint32_t alignment = interp_kernel_get_arg_align(ker->opaque, arg); assert(alignment != 0); cl_mem mem = ker->args[arg].mem; raw_size += mem->size; @@ -133,7 +133,7 @@ cl_upload_constant_buffer(cl_command_queue queue, cl_kernel ker) /* upload the global constant data */ if (global_const_size > 0) { - gbe_program_get_global_constant_data(prog, (char*)(cst_addr+offset)); + interp_program_get_global_constant_data(prog, (char*)(cst_addr+offset)); offset += global_const_size; } @@ -145,12 +145,12 @@ cl_upload_constant_buffer(cl_command_queue queue, cl_kernel ker) /* upload constant buffer argument */ int32_t curbe_offset = 0; for (arg = 0; arg < arg_n; ++arg) { - const enum gbe_arg_type type = gbe_kernel_get_arg_type(ker->opaque, arg); + const enum gbe_arg_type type = interp_kernel_get_arg_type(ker->opaque, arg); if (type == GBE_ARG_CONSTANT_PTR && ker->args[arg].mem) { cl_mem mem = ker->args[arg].mem; - uint32_t alignment = gbe_kernel_get_arg_align(ker->opaque, arg); + uint32_t alignment = interp_kernel_get_arg_align(ker->opaque, arg); offset = ALIGN(offset, alignment); - curbe_offset = gbe_kernel_get_curbe_offset(ker->opaque, GBE_CURBE_KERNEL_ARGUMENT, arg); + curbe_offset = interp_kernel_get_curbe_offset(ker->opaque, GBE_CURBE_KERNEL_ARGUMENT, arg); assert(curbe_offset >= 0); *(uint32_t *) (ker->curbe + curbe_offset) = offset; @@ -175,7 +175,7 @@ cl_curbe_fill(cl_kernel ker, { int32_t offset; #define UPLOAD(ENUM, VALUE) \ - if ((offset = gbe_kernel_get_curbe_offset(ker->opaque, ENUM, 0)) >= 0) \ + if ((offset = interp_kernel_get_curbe_offset(ker->opaque, ENUM, 0)) >= 0) \ *((uint32_t *) (ker->curbe + offset)) = VALUE; UPLOAD(GBE_CURBE_LOCAL_SIZE_X, local_wk_sz[0]); UPLOAD(GBE_CURBE_LOCAL_SIZE_Y, local_wk_sz[1]); @@ -196,24 +196,24 @@ cl_curbe_fill(cl_kernel ker, /* Write identity for the stack pointer. This is required by the stack pointer * computation in the kernel */ - if ((offset = gbe_kernel_get_curbe_offset(ker->opaque, GBE_CURBE_STACK_POINTER, 0)) >= 0) { - const uint32_t simd_sz = gbe_kernel_get_simd_width(ker->opaque); + if ((offset = interp_kernel_get_curbe_offset(ker->opaque, GBE_CURBE_STACK_POINTER, 0)) >= 0) { + const uint32_t simd_sz = interp_kernel_get_simd_width(ker->opaque); uint32_t *stackptr = (uint32_t *) (ker->curbe + offset); int32_t i; for (i = 0; i < (int32_t) simd_sz; ++i) stackptr[i] = i; } /* Handle the various offsets to SLM */ - const int32_t arg_n = gbe_kernel_get_arg_num(ker->opaque); - int32_t arg, slm_offset = gbe_kernel_get_slm_size(ker->opaque); + const int32_t arg_n = interp_kernel_get_arg_num(ker->opaque); + int32_t arg, slm_offset = interp_kernel_get_slm_size(ker->opaque); ker->local_mem_sz = 0; for (arg = 0; arg < arg_n; ++arg) { - const enum gbe_arg_type type = gbe_kernel_get_arg_type(ker->opaque, arg); + const enum gbe_arg_type type = interp_kernel_get_arg_type(ker->opaque, arg); if (type != GBE_ARG_LOCAL_PTR) continue; - uint32_t align = gbe_kernel_get_arg_align(ker->opaque, arg); + uint32_t align = interp_kernel_get_arg_align(ker->opaque, arg); assert(align != 0); slm_offset = ALIGN(slm_offset, align); - offset = gbe_kernel_get_curbe_offset(ker->opaque, GBE_CURBE_KERNEL_ARGUMENT, arg); + offset = interp_kernel_get_curbe_offset(ker->opaque, GBE_CURBE_KERNEL_ARGUMENT, arg); assert(offset >= 0); uint32_t *slmptr = (uint32_t *) (ker->curbe + offset); *slmptr = slm_offset; @@ -231,7 +231,7 @@ cl_bind_stack(cl_gpgpu gpgpu, cl_kernel ker) const int32_t per_lane_stack_sz = ker->stack_size; const int32_t value = GBE_CURBE_EXTRA_ARGUMENT; const int32_t sub_value = GBE_STACK_BUFFER; - const int32_t offset = gbe_kernel_get_curbe_offset(ker->opaque, value, sub_value); + const int32_t offset = interp_kernel_get_curbe_offset(ker->opaque, value, sub_value); int32_t stack_sz = per_lane_stack_sz; /* No stack required for this kernel */ @@ -242,7 +242,7 @@ cl_bind_stack(cl_gpgpu gpgpu, cl_kernel ker) * the size we need for the complete machine */ assert(offset >= 0); - stack_sz *= gbe_kernel_get_simd_width(ker->opaque); + stack_sz *= interp_kernel_get_simd_width(ker->opaque); stack_sz *= device->max_compute_unit; cl_gpgpu_set_stack(gpgpu, offset, stack_sz, cl_gpgpu_get_cache_ctrl()); } @@ -250,13 +250,13 @@ cl_bind_stack(cl_gpgpu gpgpu, cl_kernel ker) static void cl_bind_printf(cl_gpgpu gpgpu, cl_kernel ker, void* printf_info, int printf_num, size_t global_sz) { int32_t value = GBE_CURBE_PRINTF_INDEX_POINTER; - int32_t offset = gbe_kernel_get_curbe_offset(ker->opaque, value, 0); + int32_t offset = interp_kernel_get_curbe_offset(ker->opaque, value, 0); size_t buf_size = global_sz * sizeof(int) * printf_num; cl_gpgpu_set_printf_buffer(gpgpu, 0, buf_size, offset); value = GBE_CURBE_PRINTF_BUF_POINTER; - offset = gbe_kernel_get_curbe_offset(ker->opaque, value, 0); - buf_size = gbe_get_printf_sizeof_size(printf_info) * global_sz; + offset = interp_kernel_get_curbe_offset(ker->opaque, value, 0); + buf_size = interp_get_printf_sizeof_size(printf_info) * global_sz; cl_gpgpu_set_printf_buffer(gpgpu, 1, buf_size, offset); } @@ -274,8 +274,8 @@ cl_command_queue_ND_range_gen7(cl_command_queue queue, cl_gpgpu_kernel kernel; const uint32_t simd_sz = cl_kernel_get_simd_width(ker); size_t i, batch_sz = 0u, local_sz = 0u; - size_t cst_sz = ker->curbe_sz= gbe_kernel_get_curbe_size(ker->opaque); - int32_t scratch_sz = gbe_kernel_get_scratch_size(ker->opaque); + size_t cst_sz = ker->curbe_sz= interp_kernel_get_curbe_size(ker->opaque); + int32_t scratch_sz = interp_kernel_get_scratch_size(ker->opaque); size_t thread_n = 0u; int printf_num = 0; cl_int err = CL_SUCCESS; @@ -288,7 +288,7 @@ cl_command_queue_ND_range_gen7(cl_command_queue queue, kernel.bo = ker->bo; kernel.barrierID = 0; kernel.slm_sz = 0; - kernel.use_slm = gbe_kernel_use_slm(ker->opaque); + kernel.use_slm = interp_kernel_use_slm(ker->opaque); /* Compute the number of HW threads we need */ TRY (cl_kernel_work_group_sz, ker, local_wk_sz, 3, &local_sz); @@ -314,7 +314,7 @@ cl_command_queue_ND_range_gen7(cl_command_queue queue, } } - printf_info = gbe_dup_printfset(ker->opaque); + printf_info = interp_dup_printfset(ker->opaque); cl_gpgpu_set_printf_info(gpgpu, printf_info, (size_t *)global_wk_sz); /* Setup the kernel */ @@ -323,7 +323,7 @@ cl_command_queue_ND_range_gen7(cl_command_queue queue, else cl_gpgpu_state_init(gpgpu, ctx->device->max_compute_unit, cst_sz / 32, 0); - printf_num = gbe_get_printf_num(printf_info); + printf_num = interp_get_printf_num(printf_info); if (printf_num) { cl_bind_printf(gpgpu, ker, printf_info, printf_num, global_size); } diff --git a/src/cl_device_id.c b/src/cl_device_id.c index c25adf5..51d2e13 100644 --- a/src/cl_device_id.c +++ b/src/cl_device_id.c @@ -476,7 +476,7 @@ cl_get_kernel_workgroup_info(cl_kernel kernel, DECL_FIELD(PREFERRED_WORK_GROUP_SIZE_MULTIPLE, device->preferred_wg_sz_mul) case CL_KERNEL_LOCAL_MEM_SIZE: { - size_t local_mem_sz = gbe_kernel_get_slm_size(kernel->opaque) + kernel->local_mem_sz; + size_t local_mem_sz = interp_kernel_get_slm_size(kernel->opaque) + kernel->local_mem_sz; _DECL_FIELD(local_mem_sz) } DECL_FIELD(COMPILE_WORK_GROUP_SIZE, kernel->compile_wg_sz) diff --git a/src/cl_gbe_loader.cpp b/src/cl_gbe_loader.cpp index 38f9ab6..56e3445 100644 --- a/src/cl_gbe_loader.cpp +++ b/src/cl_gbe_loader.cpp @@ -30,40 +30,40 @@ gbe_kernel_set_const_buffer_size_cb *compiler_kernel_set_const_buffer_size = NUL gbe_set_image_base_index_cb *compiler_set_image_base_index = NULL; //function pointer from libgbeinterp.so -gbe_program_new_from_binary_cb *gbe_program_new_from_binary = NULL; -gbe_program_get_global_constant_size_cb *gbe_program_get_global_constant_size = NULL; -gbe_program_get_global_constant_data_cb *gbe_program_get_global_constant_data = NULL; -gbe_program_delete_cb *gbe_program_delete = NULL; -gbe_program_get_kernel_num_cb *gbe_program_get_kernel_num = NULL; -gbe_program_get_kernel_by_name_cb *gbe_program_get_kernel_by_name = NULL; -gbe_program_get_kernel_cb *gbe_program_get_kernel = NULL; -gbe_kernel_get_name_cb *gbe_kernel_get_name = NULL; -gbe_kernel_get_code_cb *gbe_kernel_get_code = NULL; -gbe_kernel_get_code_size_cb *gbe_kernel_get_code_size = NULL; -gbe_kernel_get_arg_num_cb *gbe_kernel_get_arg_num = NULL; -gbe_kernel_get_arg_size_cb *gbe_kernel_get_arg_size = NULL; -gbe_kernel_get_arg_type_cb *gbe_kernel_get_arg_type = NULL; -gbe_kernel_get_arg_align_cb *gbe_kernel_get_arg_align = NULL; -gbe_kernel_get_simd_width_cb *gbe_kernel_get_simd_width = NULL; -gbe_kernel_get_curbe_offset_cb *gbe_kernel_get_curbe_offset = NULL; -gbe_kernel_get_curbe_size_cb *gbe_kernel_get_curbe_size = NULL; -gbe_kernel_get_stack_size_cb *gbe_kernel_get_stack_size = NULL; -gbe_kernel_get_scratch_size_cb *gbe_kernel_get_scratch_size = NULL; -gbe_kernel_get_required_work_group_size_cb *gbe_kernel_get_required_work_group_size = NULL; -gbe_kernel_use_slm_cb *gbe_kernel_use_slm = NULL; -gbe_kernel_get_slm_size_cb *gbe_kernel_get_slm_size = NULL; -gbe_kernel_get_sampler_size_cb *gbe_kernel_get_sampler_size = NULL; -gbe_kernel_get_sampler_data_cb *gbe_kernel_get_sampler_data = NULL; -gbe_kernel_get_compile_wg_size_cb *gbe_kernel_get_compile_wg_size = NULL; -gbe_kernel_get_image_size_cb *gbe_kernel_get_image_size = NULL; -gbe_kernel_get_image_data_cb *gbe_kernel_get_image_data = NULL; -gbe_set_image_base_index_cb *gbe_set_image_base_index_interp = NULL; -gbe_get_image_base_index_cb *gbe_get_image_base_index = NULL; -gbe_get_printf_num_cb* gbe_get_printf_num = NULL; -gbe_dup_printfset_cb* gbe_dup_printfset = NULL; -gbe_get_printf_sizeof_size_cb* gbe_get_printf_sizeof_size = NULL; -gbe_release_printf_info_cb* gbe_release_printf_info = NULL; -gbe_output_printf_cb* gbe_output_printf = NULL; +gbe_program_new_from_binary_cb *interp_program_new_from_binary = NULL; +gbe_program_get_global_constant_size_cb *interp_program_get_global_constant_size = NULL; +gbe_program_get_global_constant_data_cb *interp_program_get_global_constant_data = NULL; +gbe_program_delete_cb *interp_program_delete = NULL; +gbe_program_get_kernel_num_cb *interp_program_get_kernel_num = NULL; +gbe_program_get_kernel_by_name_cb *interp_program_get_kernel_by_name = NULL; +gbe_program_get_kernel_cb *interp_program_get_kernel = NULL; +gbe_kernel_get_name_cb *interp_kernel_get_name = NULL; +gbe_kernel_get_code_cb *interp_kernel_get_code = NULL; +gbe_kernel_get_code_size_cb *interp_kernel_get_code_size = NULL; +gbe_kernel_get_arg_num_cb *interp_kernel_get_arg_num = NULL; +gbe_kernel_get_arg_size_cb *interp_kernel_get_arg_size = NULL; +gbe_kernel_get_arg_type_cb *interp_kernel_get_arg_type = NULL; +gbe_kernel_get_arg_align_cb *interp_kernel_get_arg_align = NULL; +gbe_kernel_get_simd_width_cb *interp_kernel_get_simd_width = NULL; +gbe_kernel_get_curbe_offset_cb *interp_kernel_get_curbe_offset = NULL; +gbe_kernel_get_curbe_size_cb *interp_kernel_get_curbe_size = NULL; +gbe_kernel_get_stack_size_cb *interp_kernel_get_stack_size = NULL; +gbe_kernel_get_scratch_size_cb *interp_kernel_get_scratch_size = NULL; +gbe_kernel_get_required_work_group_size_cb *interp_kernel_get_required_work_group_size = NULL; +gbe_kernel_use_slm_cb *interp_kernel_use_slm = NULL; +gbe_kernel_get_slm_size_cb *interp_kernel_get_slm_size = NULL; +gbe_kernel_get_sampler_size_cb *interp_kernel_get_sampler_size = NULL; +gbe_kernel_get_sampler_data_cb *interp_kernel_get_sampler_data = NULL; +gbe_kernel_get_compile_wg_size_cb *interp_kernel_get_compile_wg_size = NULL; +gbe_kernel_get_image_size_cb *interp_kernel_get_image_size = NULL; +gbe_kernel_get_image_data_cb *interp_kernel_get_image_data = NULL; +gbe_set_image_base_index_cb *interp_set_image_base_index = NULL; +gbe_get_image_base_index_cb *interp_get_image_base_index = NULL; +gbe_get_printf_num_cb* interp_get_printf_num = NULL; +gbe_dup_printfset_cb* interp_dup_printfset = NULL; +gbe_get_printf_sizeof_size_cb* interp_get_printf_sizeof_size = NULL; +gbe_release_printf_info_cb* interp_release_printf_info = NULL; +gbe_output_printf_cb* interp_output_printf = NULL; struct GbeLoaderInitializer { @@ -84,145 +84,145 @@ struct GbeLoaderInitializer path = interpPath; - dlhInterp = dlopen(interpPath, RTLD_LAZY | RTLD_LOCAL | RTLD_DEEPBIND); + dlhInterp = dlopen(interpPath, RTLD_LAZY | RTLD_LOCAL); if (dlhInterp == NULL) { return false; } - gbe_program_new_from_binary = *(gbe_program_new_from_binary_cb**)dlsym(dlhInterp, "gbe_program_new_from_binary"); - if (gbe_program_new_from_binary == NULL) + interp_program_new_from_binary = *(gbe_program_new_from_binary_cb**)dlsym(dlhInterp, "gbe_program_new_from_binary"); + if (interp_program_new_from_binary == NULL) return false; - gbe_program_get_global_constant_size = *(gbe_program_get_global_constant_size_cb**)dlsym(dlhInterp, "gbe_program_get_global_constant_size"); - if (gbe_program_get_global_constant_size == NULL) + interp_program_get_global_constant_size = *(gbe_program_get_global_constant_size_cb**)dlsym(dlhInterp, "gbe_program_get_global_constant_size"); + if (interp_program_get_global_constant_size == NULL) return false; - gbe_program_get_global_constant_data = *(gbe_program_get_global_constant_data_cb**)dlsym(dlhInterp, "gbe_program_get_global_constant_data"); - if (gbe_program_get_global_constant_data == NULL) + interp_program_get_global_constant_data = *(gbe_program_get_global_constant_data_cb**)dlsym(dlhInterp, "gbe_program_get_global_constant_data"); + if (interp_program_get_global_constant_data == NULL) return false; - gbe_program_delete = *(gbe_program_delete_cb**)dlsym(dlhInterp, "gbe_program_delete"); - if (gbe_program_delete == NULL) + interp_program_delete = *(gbe_program_delete_cb**)dlsym(dlhInterp, "gbe_program_delete"); + if (interp_program_delete == NULL) return false; - gbe_program_get_kernel_num = *(gbe_program_get_kernel_num_cb**)dlsym(dlhInterp, "gbe_program_get_kernel_num"); - if (gbe_program_get_kernel_num == NULL) + interp_program_get_kernel_num = *(gbe_program_get_kernel_num_cb**)dlsym(dlhInterp, "gbe_program_get_kernel_num"); + if (interp_program_get_kernel_num == NULL) return false; - gbe_program_get_kernel_by_name = *(gbe_program_get_kernel_by_name_cb**)dlsym(dlhInterp, "gbe_program_get_kernel_by_name"); - if (gbe_program_get_kernel_by_name == NULL) + interp_program_get_kernel_by_name = *(gbe_program_get_kernel_by_name_cb**)dlsym(dlhInterp, "gbe_program_get_kernel_by_name"); + if (interp_program_get_kernel_by_name == NULL) return false; - gbe_program_get_kernel = *(gbe_program_get_kernel_cb**)dlsym(dlhInterp, "gbe_program_get_kernel"); - if (gbe_program_get_kernel == NULL) + interp_program_get_kernel = *(gbe_program_get_kernel_cb**)dlsym(dlhInterp, "gbe_program_get_kernel"); + if (interp_program_get_kernel == NULL) return false; - gbe_kernel_get_name = *(gbe_kernel_get_name_cb**)dlsym(dlhInterp, "gbe_kernel_get_name"); - if (gbe_kernel_get_name == NULL) + interp_kernel_get_name = *(gbe_kernel_get_name_cb**)dlsym(dlhInterp, "gbe_kernel_get_name"); + if (interp_kernel_get_name == NULL) return false; - gbe_kernel_get_code = *(gbe_kernel_get_code_cb**)dlsym(dlhInterp, "gbe_kernel_get_code"); - if (gbe_kernel_get_code == NULL) + interp_kernel_get_code = *(gbe_kernel_get_code_cb**)dlsym(dlhInterp, "gbe_kernel_get_code"); + if (interp_kernel_get_code == NULL) return false; - gbe_kernel_get_code_size = *(gbe_kernel_get_code_size_cb**)dlsym(dlhInterp, "gbe_kernel_get_code_size"); - if (gbe_kernel_get_code_size == NULL) + interp_kernel_get_code_size = *(gbe_kernel_get_code_size_cb**)dlsym(dlhInterp, "gbe_kernel_get_code_size"); + if (interp_kernel_get_code_size == NULL) return false; - gbe_kernel_get_arg_num = *(gbe_kernel_get_arg_num_cb**)dlsym(dlhInterp, "gbe_kernel_get_arg_num"); - if (gbe_kernel_get_arg_num == NULL) + interp_kernel_get_arg_num = *(gbe_kernel_get_arg_num_cb**)dlsym(dlhInterp, "gbe_kernel_get_arg_num"); + if (interp_kernel_get_arg_num == NULL) return false; - gbe_kernel_get_arg_size = *(gbe_kernel_get_arg_size_cb**)dlsym(dlhInterp, "gbe_kernel_get_arg_size"); - if (gbe_kernel_get_arg_size == NULL) + interp_kernel_get_arg_size = *(gbe_kernel_get_arg_size_cb**)dlsym(dlhInterp, "gbe_kernel_get_arg_size"); + if (interp_kernel_get_arg_size == NULL) return false; - gbe_kernel_get_arg_type = *(gbe_kernel_get_arg_type_cb**)dlsym(dlhInterp, "gbe_kernel_get_arg_type"); - if (gbe_kernel_get_arg_type == NULL) + interp_kernel_get_arg_type = *(gbe_kernel_get_arg_type_cb**)dlsym(dlhInterp, "gbe_kernel_get_arg_type"); + if (interp_kernel_get_arg_type == NULL) return false; - gbe_kernel_get_arg_align = *(gbe_kernel_get_arg_align_cb**)dlsym(dlhInterp, "gbe_kernel_get_arg_align"); - if (gbe_kernel_get_arg_align == NULL) + interp_kernel_get_arg_align = *(gbe_kernel_get_arg_align_cb**)dlsym(dlhInterp, "gbe_kernel_get_arg_align"); + if (interp_kernel_get_arg_align == NULL) return false; - gbe_kernel_get_simd_width = *(gbe_kernel_get_simd_width_cb**)dlsym(dlhInterp, "gbe_kernel_get_simd_width"); - if (gbe_kernel_get_simd_width == NULL) + interp_kernel_get_simd_width = *(gbe_kernel_get_simd_width_cb**)dlsym(dlhInterp, "gbe_kernel_get_simd_width"); + if (interp_kernel_get_simd_width == NULL) return false; - gbe_kernel_get_curbe_offset = *(gbe_kernel_get_curbe_offset_cb**)dlsym(dlhInterp, "gbe_kernel_get_curbe_offset"); - if (gbe_kernel_get_curbe_offset == NULL) + interp_kernel_get_curbe_offset = *(gbe_kernel_get_curbe_offset_cb**)dlsym(dlhInterp, "gbe_kernel_get_curbe_offset"); + if (interp_kernel_get_curbe_offset == NULL) return false; - gbe_kernel_get_curbe_size = *(gbe_kernel_get_curbe_size_cb**)dlsym(dlhInterp, "gbe_kernel_get_curbe_size"); - if (gbe_kernel_get_curbe_size == NULL) + interp_kernel_get_curbe_size = *(gbe_kernel_get_curbe_size_cb**)dlsym(dlhInterp, "gbe_kernel_get_curbe_size"); + if (interp_kernel_get_curbe_size == NULL) return false; - gbe_kernel_get_stack_size = *(gbe_kernel_get_stack_size_cb**)dlsym(dlhInterp, "gbe_kernel_get_stack_size"); - if (gbe_kernel_get_stack_size == NULL) + interp_kernel_get_stack_size = *(gbe_kernel_get_stack_size_cb**)dlsym(dlhInterp, "gbe_kernel_get_stack_size"); + if (interp_kernel_get_stack_size == NULL) return false; - gbe_kernel_get_scratch_size = *(gbe_kernel_get_scratch_size_cb**)dlsym(dlhInterp, "gbe_kernel_get_scratch_size"); - if (gbe_kernel_get_scratch_size == NULL) + interp_kernel_get_scratch_size = *(gbe_kernel_get_scratch_size_cb**)dlsym(dlhInterp, "gbe_kernel_get_scratch_size"); + if (interp_kernel_get_scratch_size == NULL) return false; - gbe_kernel_get_required_work_group_size = *(gbe_kernel_get_required_work_group_size_cb**)dlsym(dlhInterp, "gbe_kernel_get_required_work_group_size"); - if (gbe_kernel_get_required_work_group_size == NULL) + interp_kernel_get_required_work_group_size = *(gbe_kernel_get_required_work_group_size_cb**)dlsym(dlhInterp, "gbe_kernel_get_required_work_group_size"); + if (interp_kernel_get_required_work_group_size == NULL) return false; - gbe_kernel_use_slm = *(gbe_kernel_use_slm_cb**)dlsym(dlhInterp, "gbe_kernel_use_slm"); - if (gbe_kernel_use_slm == NULL) + interp_kernel_use_slm = *(gbe_kernel_use_slm_cb**)dlsym(dlhInterp, "gbe_kernel_use_slm"); + if (interp_kernel_use_slm == NULL) return false; - gbe_kernel_get_slm_size = *(gbe_kernel_get_slm_size_cb**)dlsym(dlhInterp, "gbe_kernel_get_slm_size"); - if (gbe_kernel_get_slm_size == NULL) + interp_kernel_get_slm_size = *(gbe_kernel_get_slm_size_cb**)dlsym(dlhInterp, "gbe_kernel_get_slm_size"); + if (interp_kernel_get_slm_size == NULL) return false; - gbe_kernel_get_sampler_size = *(gbe_kernel_get_sampler_size_cb**)dlsym(dlhInterp, "gbe_kernel_get_sampler_size"); - if (gbe_kernel_get_sampler_size == NULL) + interp_kernel_get_sampler_size = *(gbe_kernel_get_sampler_size_cb**)dlsym(dlhInterp, "gbe_kernel_get_sampler_size"); + if (interp_kernel_get_sampler_size == NULL) return false; - gbe_kernel_get_sampler_data = *(gbe_kernel_get_sampler_data_cb**)dlsym(dlhInterp, "gbe_kernel_get_sampler_data"); - if (gbe_kernel_get_sampler_data == NULL) + interp_kernel_get_sampler_data = *(gbe_kernel_get_sampler_data_cb**)dlsym(dlhInterp, "gbe_kernel_get_sampler_data"); + if (interp_kernel_get_sampler_data == NULL) return false; - gbe_kernel_get_compile_wg_size = *(gbe_kernel_get_compile_wg_size_cb**)dlsym(dlhInterp, "gbe_kernel_get_compile_wg_size"); - if (gbe_kernel_get_compile_wg_size == NULL) + interp_kernel_get_compile_wg_size = *(gbe_kernel_get_compile_wg_size_cb**)dlsym(dlhInterp, "gbe_kernel_get_compile_wg_size"); + if (interp_kernel_get_compile_wg_size == NULL) return false; - gbe_kernel_get_image_size = *(gbe_kernel_get_image_size_cb**)dlsym(dlhInterp, "gbe_kernel_get_image_size"); - if (gbe_kernel_get_image_size == NULL) + interp_kernel_get_image_size = *(gbe_kernel_get_image_size_cb**)dlsym(dlhInterp, "gbe_kernel_get_image_size"); + if (interp_kernel_get_image_size == NULL) return false; - gbe_kernel_get_image_data = *(gbe_kernel_get_image_data_cb**)dlsym(dlhInterp, "gbe_kernel_get_image_data"); - if (gbe_kernel_get_image_data == NULL) + interp_kernel_get_image_data = *(gbe_kernel_get_image_data_cb**)dlsym(dlhInterp, "gbe_kernel_get_image_data"); + if (interp_kernel_get_image_data == NULL) return false; - gbe_set_image_base_index_interp = *(gbe_set_image_base_index_cb**)dlsym(dlhInterp, "gbe_set_image_base_index"); - if (gbe_set_image_base_index_interp == NULL) + interp_set_image_base_index = *(gbe_set_image_base_index_cb**)dlsym(dlhInterp, "gbe_set_image_base_index"); + if (interp_set_image_base_index == NULL) return false; - gbe_get_image_base_index = *(gbe_get_image_base_index_cb**)dlsym(dlhInterp, "gbe_get_image_base_index"); - if (gbe_get_image_base_index == NULL) + interp_get_image_base_index = *(gbe_get_image_base_index_cb**)dlsym(dlhInterp, "gbe_get_image_base_index"); + if (interp_get_image_base_index == NULL) return false; - gbe_get_printf_num = *(gbe_get_printf_num_cb**)dlsym(dlhInterp, "gbe_get_printf_num"); - if (gbe_get_printf_num == NULL) + interp_get_printf_num = *(gbe_get_printf_num_cb**)dlsym(dlhInterp, "gbe_get_printf_num"); + if (interp_get_printf_num == NULL) return false; - gbe_dup_printfset = *(gbe_dup_printfset_cb**)dlsym(dlhInterp, "gbe_dup_printfset"); - if (gbe_dup_printfset == NULL) + interp_dup_printfset = *(gbe_dup_printfset_cb**)dlsym(dlhInterp, "gbe_dup_printfset"); + if (interp_dup_printfset == NULL) return false; - gbe_get_printf_sizeof_size = *(gbe_get_printf_sizeof_size_cb**)dlsym(dlhInterp, "gbe_get_printf_sizeof_size"); - if (gbe_get_printf_sizeof_size == NULL) + interp_get_printf_sizeof_size = *(gbe_get_printf_sizeof_size_cb**)dlsym(dlhInterp, "gbe_get_printf_sizeof_size"); + if (interp_get_printf_sizeof_size == NULL) return false; - gbe_release_printf_info = *(gbe_release_printf_info_cb**)dlsym(dlhInterp, "gbe_release_printf_info"); - if (gbe_release_printf_info == NULL) + interp_release_printf_info = *(gbe_release_printf_info_cb**)dlsym(dlhInterp, "gbe_release_printf_info"); + if (interp_release_printf_info == NULL) return false; - gbe_output_printf = *(gbe_output_printf_cb**)dlsym(dlhInterp, "gbe_output_printf"); - if (gbe_output_printf == NULL) + interp_output_printf = *(gbe_output_printf_cb**)dlsym(dlhInterp, "gbe_output_printf"); + if (interp_output_printf == NULL) return false; return true; diff --git a/src/cl_gbe_loader.h b/src/cl_gbe_loader.h index f97f296..93da91c 100644 --- a/src/cl_gbe_loader.h +++ b/src/cl_gbe_loader.h @@ -29,7 +29,42 @@ extern gbe_program_serialize_to_binary_cb *compiler_program_serialize_to_binary; extern gbe_program_new_from_llvm_cb *compiler_program_new_from_llvm; extern gbe_kernel_set_const_buffer_size_cb *compiler_kernel_set_const_buffer_size; extern gbe_set_image_base_index_cb *compiler_set_image_base_index; -extern gbe_set_image_base_index_cb *gbe_set_image_base_index_interp; + +extern gbe_program_new_from_binary_cb *interp_program_new_from_binary; +extern gbe_program_get_global_constant_size_cb *interp_program_get_global_constant_size; +extern gbe_program_get_global_constant_data_cb *interp_program_get_global_constant_data; +extern gbe_program_delete_cb *interp_program_delete; +extern gbe_program_get_kernel_num_cb *interp_program_get_kernel_num; +extern gbe_program_get_kernel_by_name_cb *interp_program_get_kernel_by_name; +extern gbe_program_get_kernel_cb *interp_program_get_kernel; +extern gbe_kernel_get_name_cb *interp_kernel_get_name; +extern gbe_kernel_get_code_cb *interp_kernel_get_code; +extern gbe_kernel_get_code_size_cb *interp_kernel_get_code_size; +extern gbe_kernel_get_arg_num_cb *interp_kernel_get_arg_num; +extern gbe_kernel_get_arg_size_cb *interp_kernel_get_arg_size; +extern gbe_kernel_get_arg_type_cb *interp_kernel_get_arg_type; +extern gbe_kernel_get_arg_align_cb *interp_kernel_get_arg_align; +extern gbe_kernel_get_simd_width_cb *interp_kernel_get_simd_width; +extern gbe_kernel_get_curbe_offset_cb *interp_kernel_get_curbe_offset; +extern gbe_kernel_get_curbe_size_cb *interp_kernel_get_curbe_size; +extern gbe_kernel_get_stack_size_cb *interp_kernel_get_stack_size; +extern gbe_kernel_get_scratch_size_cb *interp_kernel_get_scratch_size; +extern gbe_kernel_get_required_work_group_size_cb *interp_kernel_get_required_work_group_size; +extern gbe_kernel_use_slm_cb *interp_kernel_use_slm; +extern gbe_kernel_get_slm_size_cb *interp_kernel_get_slm_size; +extern gbe_kernel_get_sampler_size_cb *interp_kernel_get_sampler_size; +extern gbe_kernel_get_sampler_data_cb *interp_kernel_get_sampler_data; +extern gbe_kernel_get_compile_wg_size_cb *interp_kernel_get_compile_wg_size; +extern gbe_kernel_get_image_size_cb *interp_kernel_get_image_size; +extern gbe_kernel_get_image_data_cb *interp_kernel_get_image_data; +extern gbe_set_image_base_index_cb *interp_set_image_base_index; +extern gbe_get_image_base_index_cb *interp_get_image_base_index; +extern gbe_get_printf_num_cb* interp_get_printf_num; +extern gbe_dup_printfset_cb* interp_dup_printfset; +extern gbe_get_printf_sizeof_size_cb* interp_get_printf_sizeof_size; +extern gbe_release_printf_info_cb* interp_release_printf_info; +extern gbe_output_printf_cb* interp_output_printf; + int CompilerSupported(); #ifdef __cplusplus } diff --git a/src/cl_kernel.c b/src/cl_kernel.c index a45e281..5fc3e44 100644 --- a/src/cl_kernel.c +++ b/src/cl_kernel.c @@ -83,7 +83,7 @@ LOCAL const char* cl_kernel_get_name(cl_kernel k) { if (UNLIKELY(k == NULL)) return NULL; - return gbe_kernel_get_name(k->opaque); + return interp_kernel_get_name(k->opaque); } LOCAL void @@ -102,8 +102,8 @@ cl_kernel_set_arg(cl_kernel k, cl_uint index, size_t sz, const void *value) if (UNLIKELY(index >= k->arg_n)) return CL_INVALID_ARG_INDEX; - arg_type = gbe_kernel_get_arg_type(k->opaque, index); - arg_sz = gbe_kernel_get_arg_size(k->opaque, index); + arg_type = interp_kernel_get_arg_type(k->opaque, index); + arg_sz = interp_kernel_get_arg_size(k->opaque, index); if (UNLIKELY(arg_type != GBE_ARG_LOCAL_PTR && arg_sz != sz)) { if (arg_sz == 2 && arg_type == GBE_ARG_VALUE && sz == sizeof(cl_sampler)) { @@ -147,7 +147,7 @@ cl_kernel_set_arg(cl_kernel k, cl_uint index, size_t sz, const void *value) /* Copy the structure or the value directly into the curbe */ if (arg_type == GBE_ARG_VALUE) { - offset = gbe_kernel_get_curbe_offset(k->opaque, GBE_CURBE_KERNEL_ARGUMENT, index); + offset = interp_kernel_get_curbe_offset(k->opaque, GBE_CURBE_KERNEL_ARGUMENT, index); assert(offset + sz <= k->curbe_sz); memcpy(k->curbe + offset, value, sz); k->args[index].local_sz = 0; @@ -173,7 +173,7 @@ cl_kernel_set_arg(cl_kernel k, cl_uint index, size_t sz, const void *value) k->args[index].mem = NULL; k->args[index].sampler = sampler; cl_set_sampler_arg_slot(k, index, sampler); - offset = gbe_kernel_get_curbe_offset(k->opaque, GBE_CURBE_KERNEL_ARGUMENT, index); + offset = interp_kernel_get_curbe_offset(k->opaque, GBE_CURBE_KERNEL_ARGUMENT, index); assert(offset + 2 <= k->curbe_sz); memcpy(k->curbe + offset, &sampler->clkSamplerValue, 2); return CL_SUCCESS; @@ -184,7 +184,7 @@ cl_kernel_set_arg(cl_kernel k, cl_uint index, size_t sz, const void *value) if(value == NULL || mem == NULL) { /* for buffer object GLOBAL_PTR CONSTANT_PTR, it maybe NULL */ - int32_t offset = gbe_kernel_get_curbe_offset(k->opaque, GBE_CURBE_KERNEL_ARGUMENT, index); + int32_t offset = interp_kernel_get_curbe_offset(k->opaque, GBE_CURBE_KERNEL_ARGUMENT, index); *((uint32_t *)(k->curbe + offset)) = 0; assert(arg_type == GBE_ARG_GLOBAL_PTR || arg_type == GBE_ARG_CONSTANT_PTR); @@ -212,7 +212,7 @@ LOCAL uint32_t cl_kernel_get_simd_width(cl_kernel k) { assert(k != NULL); - return gbe_kernel_get_simd_width(k->opaque); + return interp_kernel_get_simd_width(k->opaque); } LOCAL void @@ -225,31 +225,31 @@ cl_kernel_setup(cl_kernel k, gbe_kernel opaque) cl_buffer_unreference(k->bo); /* Allocate the gen code here */ - const uint32_t code_sz = gbe_kernel_get_code_size(opaque); - const char *code = gbe_kernel_get_code(opaque); + const uint32_t code_sz = interp_kernel_get_code_size(opaque); + const char *code = interp_kernel_get_code(opaque); k->bo = cl_buffer_alloc(bufmgr, "CL kernel", code_sz, 64u); - k->arg_n = gbe_kernel_get_arg_num(opaque); + k->arg_n = interp_kernel_get_arg_num(opaque); /* Upload the code */ cl_buffer_subdata(k->bo, 0, code_sz, code); k->opaque = opaque; /* Create the curbe */ - k->curbe_sz = gbe_kernel_get_curbe_size(k->opaque); + k->curbe_sz = interp_kernel_get_curbe_size(k->opaque); /* Get sampler data & size */ - k->sampler_sz = gbe_kernel_get_sampler_size(k->opaque); + k->sampler_sz = interp_kernel_get_sampler_size(k->opaque); assert(k->sampler_sz <= GEN_MAX_SAMPLERS); if (k->sampler_sz > 0) - gbe_kernel_get_sampler_data(k->opaque, k->samplers); - gbe_kernel_get_compile_wg_size(k->opaque, k->compile_wg_sz); - k->stack_size = gbe_kernel_get_stack_size(k->opaque); + interp_kernel_get_sampler_data(k->opaque, k->samplers); + interp_kernel_get_compile_wg_size(k->opaque, k->compile_wg_sz); + k->stack_size = interp_kernel_get_stack_size(k->opaque); /* Get image data & size */ - k->image_sz = gbe_kernel_get_image_size(k->opaque); + k->image_sz = interp_kernel_get_image_size(k->opaque); assert(k->sampler_sz <= GEN_MAX_SURFACES); if (k->image_sz > 0) { TRY_ALLOC_NO_ERR(k->images, cl_calloc(k->image_sz, sizeof(k->images[0]))); - gbe_kernel_get_image_data(k->opaque, k->images); + interp_kernel_get_image_data(k->opaque, k->images); } else k->images = NULL; return; @@ -317,7 +317,7 @@ cl_kernel_work_group_sz(cl_kernel ker, cl_uint i; for (i = 0; i < wk_dim; ++i) { - const uint32_t required_sz = gbe_kernel_get_required_work_group_size(ker->opaque, i); + const uint32_t required_sz = interp_kernel_get_required_work_group_size(ker->opaque, i); if (required_sz != 0 && required_sz != local_wk_sz[i]) { err = CL_INVALID_WORK_ITEM_SIZE; goto error; diff --git a/src/cl_program.c b/src/cl_program.c index 42058e8..41bf67a 100644 --- a/src/cl_program.c +++ b/src/cl_program.c @@ -93,7 +93,7 @@ cl_program_delete(cl_program p) cl_context_delete(p->ctx); /* Free the program as allocated by the compiler */ - if (p->opaque) gbe_program_delete(p->opaque); + if (p->opaque) interp_program_delete(p->opaque); p->magic = CL_MAGIC_DEAD_HEADER; /* For safety */ cl_free(p); @@ -137,13 +137,13 @@ cl_program_load_gen_program(cl_program p) uint32_t i; assert(p->opaque != NULL); - p->ker_n = gbe_program_get_kernel_num(p->opaque); + p->ker_n = interp_program_get_kernel_num(p->opaque); /* Allocate the kernel array */ TRY_ALLOC (p->ker, CALLOC_ARRAY(cl_kernel, p->ker_n)); for (i = 0; i < p->ker_n; ++i) { - const gbe_kernel opaque = gbe_program_get_kernel(p->opaque, i); + const gbe_kernel opaque = interp_program_get_kernel(p->opaque, i); assert(opaque != NULL); TRY_ALLOC (p->ker[i], cl_kernel_new(p)); cl_kernel_setup(p->ker[i], opaque); @@ -345,7 +345,7 @@ cl_program_build(cl_program p, const char *options) TRY (cl_program_load_gen_program, p); p->source_type = FROM_LLVM; } else if (p->source_type == FROM_BINARY) { - p->opaque = gbe_program_new_from_binary(p->ctx->device->vendor_id, p->binary, p->binary_sz); + p->opaque = interp_program_new_from_binary(p->ctx->device->vendor_id, p->binary, p->binary_sz); if (UNLIKELY(p->opaque == NULL)) { err = CL_BUILD_PROGRAM_FAILURE; goto error; @@ -357,16 +357,16 @@ cl_program_build(cl_program p, const char *options) } for (i = 0; i < p->ker_n; i ++) { - const gbe_kernel opaque = gbe_program_get_kernel(p->opaque, i); - p->bin_sz += gbe_kernel_get_code_size(opaque); + const gbe_kernel opaque = interp_program_get_kernel(p->opaque, i); + p->bin_sz += interp_kernel_get_code_size(opaque); } TRY_ALLOC (p->bin, cl_calloc(p->bin_sz, sizeof(char))); for (i = 0; i < p->ker_n; i ++) { - const gbe_kernel opaque = gbe_program_get_kernel(p->opaque, i); - size_t sz = gbe_kernel_get_code_size(opaque); + const gbe_kernel opaque = interp_program_get_kernel(p->opaque, i); + size_t sz = interp_kernel_get_code_size(opaque); - memcpy(p->bin + copyed, gbe_kernel_get_code(opaque), sz); + memcpy(p->bin + copyed, interp_kernel_get_code(opaque), sz); copyed += sz; } diff --git a/src/intel/intel_driver.c b/src/intel/intel_driver.c index bc6aaef..f0e860c 100644 --- a/src/intel/intel_driver.c +++ b/src/intel/intel_driver.c @@ -412,7 +412,7 @@ cl_intel_driver_new(cl_context_prop props) * when it allocates slots for images*/ if (CompilerSupported()) compiler_set_image_base_index(3); - gbe_set_image_base_index_interp(3); + interp_set_image_base_index(3); exit: return driver; error: -- 1.8.3.2 _______________________________________________ Beignet mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/beignet
