MYSQL_RES *do_mysql_cCommand_execute_async(VALUE self, VALUE connection, MYSQL *db, VALUE query) {
int retval;
if ((retval = mysql_ping(db)) && mysql_errno(db) == CR_SERVER_GONE_ERROR) {
do_mysql_full_connect(connection, db);
}
struct timeval start;
const char *str = rb_str_ptr_readonly(query);
long len = rb_str_len(query);
gettimeofday(&start, NULL);
retval = mysql_send_query(db, str, len);
CHECK_AND_RAISE(retval, query);
int socket_fd = db->net.fd;
fd_set rset;
while (1) {
FD_ZERO(&rset);
FD_SET(socket_fd, &rset);
retval = rb_thread_select(socket_fd + 1, &rset, NULL, NULL, NULL);
if (retval < 0) {
rb_sys_fail(0);
}
if (retval == 0) {
continue;
}
if (db->status == MYSQL_STATUS_READY) {
break;
}
}
retval = mysql_read_query_result(db);
CHECK_AND_RAISE(retval, query);
data_objects_debug(connection, query, &start);
MYSQL_RES *result = mysql_store_result(db);
if (!result) {
CHECK_AND_RAISE(mysql_errno(db), query);
}
return result;
}
/*
* call-seq:
* Kernel#info(CL_KERNEL_FUNCTION_NAME)
*
* Wrapps +clGetKernelInfo()+.
*/
static VALUE
rcl_kernel_info(VALUE self, VALUE param_name)
{
EXPECT_RCL_CONST(param_name);
cl_kernel k = KernelPtr(self);
cl_kernel_info ki = FIX2UINT(param_name);
char param_value[128];
size_t sz_ret;
cl_int res = clGetKernelInfo(k, ki, 128, param_value, &sz_ret);
CHECK_AND_RAISE(res);
switch (ki) {
case CL_KERNEL_FUNCTION_NAME:
return rb_str_new2(param_value);
case CL_KERNEL_NUM_ARGS:
case CL_KERNEL_REFERENCE_COUNT:
return UINT2NUM((*(cl_uint *)param_value));
case CL_KERNEL_CONTEXT:
return RContext(*(cl_context *)param_value);
case CL_KERNEL_PROGRAM:
return RProgram(*(cl_program *)param_value);
default:
break;
}
return Qnil;
}
/*
* call-seq:
* Kernel#workgroup_info(Device, CL_KERNEL_WORK_GROUP_SIZE)
*
* Wrapps +clGetKernelWorkGroupInfo()+.
*
* deivce - A Device object. Can be +nil+ if there is only single device
* is used by the context to which the receiver belongs.
* param_name - The information to query.
*/
static VALUE
rcl_kernel_workgroup_info(VALUE self, VALUE device, VALUE param_name)
{
EXPECT_RCL_TYPE(device, Device);
EXPECT_RCL_CONST(param_name);
cl_kernel k = KernelPtr(self);
cl_device_id dev = NIL_P(device) ? NULL : DevicePtr(device);
cl_kernel_work_group_info kwi = FIX2UINT(param_name);
size_t param_value[3];
cl_uint res = clGetKernelWorkGroupInfo(k, dev, kwi, sizeof(size_t) * 3, param_value, NULL);
CHECK_AND_RAISE(res);
VALUE ret = Qnil;
switch (kwi) {
case CL_KERNEL_WORK_GROUP_SIZE:
case CL_KERNEL_LOCAL_MEM_SIZE:
#ifdef CL_VERSION_1_1
case CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE:
#endif
return ULONG2NUM(param_value[0]);
case CL_KERNEL_COMPILE_WORK_GROUP_SIZE:
ret = rb_ary_new2(3);
for (int i = 0; i < 3; i++) {
rb_ary_push(ret, ULONG2NUM(param_value[i]));
}
return ret;
default:
break;
}
return Qnil;
}
/*
* call-seq:
* Memory.create_subbuffer(buffer, , [10, 100])
*
*/
static VALUE
rcl_mem_create_subbuffer(VALUE mod, VALUE buffer,
VALUE flags,
VALUE region)
{
EXPECT_RCL_TYPE(buffer, Memory);
EXPECT_FIXNUM(flags);
EXPECT_ARRAY(region);
long i = RARRAY_LEN(region);
if (i != 2) {
rb_raise(rb_eArgError, "Expected the parameter region has 2 items, got (%ld).", i);
}
VALUE sz = rb_ary_entry(region, 0);
EXTRACT_SIZE(sz, origin);
sz = rb_ary_entry(region, 1);
EXTRACT_SIZE(sz, offset);
cl_buffer_region br;
br.origin = origin;
br.size = offset;
cl_mem buf = MemoryPtr(buffer);
cl_mem_flags mf = FIX2INT(flags);
cl_int res = CL_SUCCESS;
cl_mem subbuf = clCreateSubBuffer(buf, mf, CL_BUFFER_CREATE_TYPE_REGION, &br, &res);
CHECK_AND_RAISE(res);
return RMemory(subbuf);
}
static VALUE
rcl_mem_create_image_2d(VALUE mod, VALUE context,
VALUE flags,
VALUE image_format,
VALUE width, VALUE height, VALUE row_pitch,
VALUE host_ptr)
{
EXPECT_RCL_TYPE(context, Context);
EXPECT_FIXNUM(flags);
EXTRACT_SIZE(width, w);
EXTRACT_SIZE(height, h);
EXTRACT_SIZE(row_pitch, rp);
cl_context cxt = ContextPtr(context);
cl_mem_flags mf = FIX2INT(flags);
EXTRACT_IMAGE_FORMAT(image_format, imgfmt);
EXTRACT_POINTER(host_ptr, hp);
cl_int res;
cl_mem img = clCreateImage2D(cxt, mf, &imgfmt, w, h, rp, hp, &res);
CHECK_AND_RAISE(res);
return RMemory(img);
}
static VALUE
rcl_mem_image_info(VALUE self, VALUE param_name)
{
EXPECT_RCL_CONST(param_name);
cl_image_info ii = FIX2UINT(param_name);
cl_mem m = MemoryPtr(self);
cl_image_format imgfmt;
cl_int res = clGetImageInfo(m, ii, sizeof(cl_image_format), (void *)&imgfmt, NULL);
CHECK_AND_RAISE(res);
switch (ii) {
case CL_IMAGE_FORMAT:
return RImageFormat(&imgfmt);
case CL_IMAGE_ELEMENT_SIZE:
case CL_IMAGE_ROW_PITCH:
case CL_IMAGE_SLICE_PITCH:
case CL_IMAGE_WIDTH:
case CL_IMAGE_HEIGHT:
case CL_IMAGE_DEPTH:
return ULONG2NUM(*(size_t *)&imgfmt);
}
return Qnil;
}
static VALUE
rcl_mem_info(VALUE self, VALUE param_name)
{
EXPECT_RCL_CONST(param_name);
cl_mem_info mi = FIX2UINT(param_name);
cl_mem m = MemoryPtr(self);
intptr_t param_value;
cl_int res = clGetMemObjectInfo(m, mi, sizeof(intptr_t), ¶m_value, NULL);
CHECK_AND_RAISE(res);
switch (mi) {
case CL_MEM_TYPE:
case CL_MEM_FLAGS:
case CL_MEM_SIZE:
case CL_MEM_MAP_COUNT:
case CL_MEM_REFERENCE_COUNT:
return UINT2NUM(param_value);
case CL_MEM_HOST_PTR: // CHECK: Should be wrapped to a HostPoiner? MappedPointer? No.
return ULONG2NUM(param_value);
case CL_MEM_CONTEXT:
return RContext((cl_context)param_value);
default:
break;
}
return Qnil;
}
static VALUE
rcl_mem_create_image_3d(VALUE mod, VALUE context, VALUE flags,
VALUE image_format,
VALUE width, VALUE height, VALUE depth,
VALUE row_pitch, VALUE slice_pitch,
VALUE host_ptr)
{
EXPECT_RCL_TYPE(context, Context);
EXPECT_FIXNUM(flags);
if (CLASS_OF(image_format) != rcl_cImageFormat) {
rb_raise(rb_eTypeError, "expected argument 3 is a ImageFormat.");
}
cl_mem_flags mf = FIX2INT(flags);
EXTRACT_SIZE(width, w);
EXTRACT_SIZE(height, h);
EXTRACT_SIZE(depth, d);
EXTRACT_SIZE(row_pitch, rp);
EXTRACT_SIZE(slice_pitch, sp);
cl_context cxt = ContextPtr(context);
EXTRACT_IMAGE_FORMAT(image_format, imgfmt);
EXTRACT_POINTER(host_ptr, hp);
cl_int res;
cl_mem img = clCreateImage3D(cxt, mf, &imgfmt, w, h, d, rp, sp, hp, &res);
CHECK_AND_RAISE(res);
return RMemory(img);
}
static VALUE
rcl_kernel_init_copy(VALUE copy, VALUE orig)
{
if (copy == orig) return copy;
EXPECT_RCL_TYPE(orig, Kernel);
rcl_kernel_t *copy_p, *orig_p;
Data_Get_Struct(copy, rcl_kernel_t, copy_p);
Data_Get_Struct(orig, rcl_kernel_t, orig_p);
if (copy_p->k == orig_p->k) return copy;
cl_int res;
if (copy_p->k != NULL) {
res = clReleaseKernel(copy_p->k);
CHECK_AND_RAISE(res);
}
res = clRetainKernel(orig_p->k);
CHECK_AND_RAISE(res);
copy_p->k = orig_p->k;
return copy;
}
static VALUE
rcl_kernel_set_arg(VALUE self, VALUE index, VALUE type, VALUE value)
{
EXTRACT_SIZE(index, idx);
Check_Type(type, T_SYMBOL);
size_t arg_size = 0;
int8_t *arg_ptr = NULL;
if (type == rcl_kernel_arg_type_memory) {
if (!NIL_P(value)) {
EXPECT_RCL_TYPE(value, Memory);
arg_size = sizeof(cl_mem);
rcl_mem_t *mem;
Data_Get_Struct(value, rcl_mem_t, mem);
arg_ptr = (void *)(&(mem->mem));
}
} else if (type == rcl_kernel_arg_type_local) {
EXTRACT_SIZE(value, sz);
arg_size = sz;
arg_ptr = NULL;
} else if (type == rcl_kernel_arg_type_struct) {
// TODO: rb_call pointer
// rb_call address, size
rb_notimplement();
} else if (type == rcl_kernel_arg_type_sampler) {
EXPECT_RCL_TYPE(value, Sampler);
rcl_sampler_t *ps;
Data_Get_Struct(value, rcl_sampler_t, ps);
arg_ptr = (void *)(&(ps->s));
arg_size = sizeof(cl_sampler);
} else {
arg_size = rcl_type_size(type);
arg_ptr = ALLOCA_N(int8_t, arg_size);
rcl_ruby2native(type, (void *)arg_ptr, value);
}
cl_int res = clSetKernelArg(KernelPtr(self), (cl_uint)idx, arg_size, arg_ptr);
CHECK_AND_RAISE(res);
return self;
}
static VALUE
rcl_mem_create_from_gl_buffer(VALUE self, VALUE context,
VALUE flags, VALUE bufobj)
{
EXPECT_RCL_TYPE(context, Context);
EXPECT_FIXNUM(flags);
EXPECT_FIXNUM(bufobj);
cl_context cxt = ContextPtr(context);
cl_mem_flags mf = FIX2INT(flags);
cl_GLuint glbuf = FIX2UINT(bufobj);
cl_int res;
cl_mem mem = clCreateFromGLBuffer(cxt, mf, glbuf, &res);
CHECK_AND_RAISE(res);
return RMemory(mem);
}
static MYSQL_RES* cCommand_execute_sync(VALUE self, VALUE connection, MYSQL* db, VALUE query) {
int retval;
struct timeval start;
const char* str = rb_str_ptr_readonly(query);
int len = rb_str_len(query);
if(mysql_ping(db) && mysql_errno(db) == CR_SERVER_GONE_ERROR) {
// Ok, we do one more try here by doing a full connect
VALUE connection = rb_iv_get(self, "@connection");
full_connect(connection, db);
}
gettimeofday(&start, NULL);
retval = mysql_real_query(db, str, len);
data_objects_debug(connection, query, &start);
CHECK_AND_RAISE(retval, query);
return mysql_store_result(db);
}
/*
* call-seq:
* Kernel::new(aProgram, name) -> a Kernel object.
*
* Wrapps +clCreateKernel()+.
*/
static VALUE
rcl_kernel_init(VALUE self, VALUE program, VALUE name)
{
EXPECT_RCL_TYPE(program, Program);
Check_Type(name, T_STRING);
cl_program prog = ProgramPtr(program);
const char *str = RSTRING_PTR(name);
cl_int res;
cl_kernel k = clCreateKernel(prog, str, &res);
CHECK_AND_RAISE(res);
rcl_kernel_t *pk;
Data_Get_Struct(self, rcl_kernel_t, pk);
pk->k = k;
return self;
}
/*
* call-seq:
* Memory.create_buffer(aContext, CL_MEM_FLAG_READ_WRITE, 0, aPointer)
*/
static VALUE
rcl_mem_create_buffer(VALUE mod, VALUE context, VALUE flags, VALUE size, VALUE host_ptr)
{
EXPECT_RCL_TYPE(context, Context);
EXPECT_FIXNUM(flags);
if (!NIL_P(host_ptr)) EXPECT_RCL_TYPE(host_ptr, Pointer);
cl_context cxt = ContextPtr(context);
cl_mem_flags mf = FIX2INT(flags);
EXTRACT_SIZE(size, sz);
EXTRACT_POINTER(host_ptr, hp);
if (NULL != hp && sz == 0) {
sz = FIX2UINT(rb_funcall(host_ptr, rb_intern("byte_size"), 0));
}
cl_int res;
cl_mem mem = clCreateBuffer(cxt, mf, sz, hp, &res);
CHECK_AND_RAISE(res);
return RMemory(mem);
}
