static int PushArgInfoStr(lua_State *L, cl_kernel krnl, cl_uint index, cl_kernel_arg_info param, const char * paramName) {
size_t size = 0;
cl_int err = clGetKernelArgInfo(krnl, index, param, 0, NULL, &size);
CheckCLError(L, err, "Failed requesting size of kernel arg info string: %s.");
//l_debug(L, "Pushing arg info str %s with length %d", paramName, size);
std::vector<char> value(size);
err = clGetKernelArgInfo(krnl, index, param, size, value.data(), NULL);
CheckCLError(L, err, "Failed requesting kernel arg info string: %s.");
lua_pushstring(L, std::string(value.data(), value.size()).c_str());
lua_setfield(L, -2, paramName);
return 0;
}
static int PushArgInfo(lua_State *L, cl_kernel krnl, cl_uint index, cl_kernel_arg_info param, const char * paramName) {
size_t size = 0;
cl_int err = clGetKernelArgInfo(krnl, index, param, 0, NULL, &size);
CheckCLError(L, err, "Failed requesting size of kernel arg info: %s.");
assert(size == sizeof(T));
T value = 0;
err = clGetKernelArgInfo(krnl, index, param, size, &value, NULL);
CheckCLError(L, err, "Failed requesting kernel arg info: %s.");
lua_pushnumber(L, static_cast<lua_Number>(value));
lua_setfield(L, -2, paramName);
return 0;
}
/**
* Kernel argument information adapter between a ccl_wrapper_info_fp() function
* and the clGetKernelArgInfo() function.
*
* @private @memberof ccl_kernel
* @see ccl_wrapper_info_fp()
*
* @param[in] kernel The kernel wrapper object.
* @param[in] ptr_arg_indx The kernel argument index, stuffed in a pointer.
* @param[in] param_name Name of information/parameter to get.
* @param[in] param_value_size Size in bytes of memory pointed to by
* param_value.
* @param[out] param_value A pointer to memory where the appropriate result
* being queried is returned.
* @param[out] param_value_size_ret Returns the actual size in bytes of data
* copied to param_value.
* @return CL_SUCCESS if the function is executed successfully, or an OpenCL
* error code otherwise.
* */
cl_int ccl_kernel_get_arg_info_adapter(cl_kernel kernel, void* ptr_arg_indx,
cl_kernel_arg_info param_name, size_t param_value_size, void *param_value,
size_t* param_value_size_ret) {
return clGetKernelArgInfo(kernel, GPOINTER_TO_UINT(ptr_arg_indx),
param_name, param_value_size, param_value, param_value_size_ret);
}
JNIEXPORT jint JNICALL Java_org_lwjgl_opencl_CL12_nclGetKernelArgInfo(JNIEnv *env, jclass clazz, jlong kernel, jint arg_indx, jint param_name, jlong param_value_size, jlong param_value, jlong param_value_size_ret, jlong function_pointer) {
cl_void *param_value_address = (cl_void *)(intptr_t)param_value;
size_t *param_value_size_ret_address = (size_t *)(intptr_t)param_value_size_ret;
clGetKernelArgInfoPROC clGetKernelArgInfo = (clGetKernelArgInfoPROC)((intptr_t)function_pointer);
cl_int __result = clGetKernelArgInfo((cl_kernel)(intptr_t)kernel, arg_indx, param_name, param_value_size, param_value_address, param_value_size_ret_address);
return __result;
}
T get_arg_info(size_t index, cl_kernel_arg_info info)
{
T value;
cl_int ret = clGetKernelArgInfo(m_kernel,
index,
info,
sizeof(T),
&value,
0);
if(ret != CL_SUCCESS){
BOOST_THROW_EXCEPTION(runtime_exception(ret));
}
return value;
}
rcl_status cl_create_kernel(struct client_state* state, program_t program_id,
char* name, uint32_t analyze, kernel_t* kernel_id, uint32_t* arg_count,
enum kernel_arg_value_type** arg_types)
{
int32_t index;
cl_int error;
struct kernel_state* kernel_state;
struct program_state* program_state;
rcl_status status = RCL_HOST_RESOURCE;
cl_uint count;
cl_uint i;
cl_kernel_arg_address_qualifier type;
if (!vector_valid_idx(&state->programs, program_id)) {
log_print(log_error, "Program %" PRIu32 " not found", program_id);
return RCL_INVALID_PROGRAM;
}
log_print(log_notice, "Creating kernel \"%s\" of program %" PRIu32, name,
program_id);
program_state = *vector_element(&state->programs, program_id,
struct program_state*);
kernel_state = malloc(sizeof(struct kernel_state));
if (!kernel_state)
goto out_alloc;
kernel_state->arguments = NULL;
kernel_state->name = strdup(name);
if (!kernel_state->name)
goto out_alloc;
kernel_state->program_id = program_id;
kernel_state->id = clCreateKernel(program_state->id, name, &error);
if (error != CL_SUCCESS) {
log_print(log_error, "Error creating kernel: %s", clerror_name(error));
status = opencl_error(error);
goto out_release;
}
error = clGetKernelInfo(kernel_state->id, CL_KERNEL_NUM_ARGS,
sizeof(cl_uint), &count, NULL);
if (error != CL_SUCCESS)
goto out_release;
kernel_state->argument_count = count;
kernel_state->arguments = malloc(sizeof(struct argument_state) * count);
if (!kernel_state->arguments) {
status = RCL_HOST_RESOURCE;
goto out_release;
}
memset(kernel_state->arguments, 0, sizeof(struct argument_state) * count);
if (analyze) {
assert(arg_count);
assert(arg_types);
*arg_count = count;
*arg_types = malloc(sizeof(enum kernel_arg_value_type) * count);
if (!*arg_types) {
status = RCL_HOST_RESOURCE;
goto out_release;
}
for (i = 0; i < count; i++) {
error = clGetKernelArgInfo(kernel_state->id, i,
CL_KERNEL_ARG_ADDRESS_QUALIFIER, sizeof(type), &type, NULL);
if (error)
goto out_analyze;
if (type == CL_KERNEL_ARG_ADDRESS_GLOBAL
|| type == CL_KERNEL_ARG_ADDRESS_LOCAL
|| type == CL_KERNEL_ARG_ADDRESS_CONSTANT) {
(*arg_types)[i] = KERNEL_ARGUMENT_VALUE_BUFFER;
} else
(*arg_types)[i] = KERNEL_ARGUMENT_VALUE_DATA;
}
}
index = vector_add(&state->kernels, &kernel_state);
if (index < 0) {
status = RCL_HOST_RESOURCE;
goto out_analyze;
}
*kernel_id = index;
return RCL_OK;
out_analyze:
if (analyze)
free(*arg_types);
out_release:
clReleaseKernel(kernel_state->id);
out_alloc:
if (kernel_state)
free(kernel_state->name);
if (kernel_state)
free(kernel_state->arguments);
free(kernel_state);
return status;
}
