[Beignet] [PATCH] remove RTLD_DEEPBIND to avoid stdc++ issues
Guo Yejun
yejun.guo at intel.com
Wed Jun 11 11:38:22 PDT 2014
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 <yejun.guo at intel.com>
---
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
More information about the Beignet
mailing list