barracuda 1.0 → 1.1

data/README.md

@@ -15,9 +15,6 @@ Barracuda aims to abstract both CUDA and OpenCL, however for now only OpenCL
 on OSX 10.6 is supported. Patches to extend this support would be joyously
 accepted!
 
-Also note that Barracuda currently only supports data types, namely ints and
-floats only. This should also be expanded.
-
 INSTALLING
 ----------
 
@@ -87,7 +84,7 @@ to run). Barracuda automatically selects the size of the largest buffer as
 the work group size, but in some cases this may be too small or too large. To
 manually specify the work group size, call the kernel with an options hash:
 
-    program.my_kernel_method(..., :worker_size => 512)
+    program.my_kernel_method(..., :times => 512)
     
 Note that the work group size must be a power of 2. Barracuda will increase
 the work group size to the next power of 2 if it needs to. This means your
@@ -95,6 +92,29 @@ OpenCL program might run more iterations of your kernel method than you
 request. Because we can't rely on the work group size, we pass in the total 
 data size to ensure we do not exceed the bounds of our data.
 
+CONVERTING TYPES
+----------------
+
+OpenCL has a variety of native types. Most of them are supported, however some
+are not. Because Ruby only has the concept of Float and Fixnum (integer), you
+may need to tell Barracuda the type of your input if you're trying to pass in
+a char, short or double (or possibly have some signedness restrictions). To
+do this, simply call `.to_type(:my_type)` on the input where `:my_type` is
+a key in the `Barracuda::TYPES` hash:
+
+    >> Barracuda::TYPES.keys
+    => [:bool, :char, :uchar, :short, :ushort, :int, :uint, :long, 
+        :ulong, :float, :half, :double, :size_t, :ptrdiff_t, 
+        :intptr_t, :uintptr_t]
+
+For example, to pass in a short, do:
+
+    program.my_kernel(2.to_type(:short))
+    
+This can also be applied to an Array of shorts:
+
+    program.my_kernel([1, 2, 3].to_type(:short))
+
 CLASS DETAILS
 -------------
 
@@ -110,7 +130,7 @@ Represents an OpenCL program
       - args should be the arguments defined in the kernel method.
       - supported argument types are Float and Fixnum objects only.
       - if the last arg is a Hash, it should be an options hash with keys:
-          - :worker_size => FIXNUM (the number of iterations to run)
+          - :times => FIXNUM (the number of iterations to run)
 
 **Barracuda::Buffer**:
 

data/benchmarks/normalize.rb

@@ -0,0 +1,44 @@
+$:.unshift(File.dirname(__FILE__) + '/../ext')
+
+require 'barracuda'
+require 'benchmark'
+
+include Barracuda
+
+def dist(*vec)
+  vec[0] * vec[0] + vec[1] * vec[1] + vec[2] * vec[2]
+end
+
+def normalize(*vec)
+  d = dist(*vec)
+  vec.map {|c| c / d }
+end
+
+def norm_all(arr)
+  out = []
+  0.step(arr.size - 1, 4) do |i|
+    vec = normalize(arr[i], arr[i + 1], arr[i + 2])
+    out.push(*vec, 0.0)
+  end
+  out
+end
+
+srand
+prog = Program.new <<-'eof'
+  __kernel norm(__global float4 *out, __global float4 *in, int total) {
+    int i = get_global_id(0);
+    if (i < total) out[i] = normalize(in[i]);
+  }
+eof
+
+num_vecs = 100000
+arr = []
+num_vecs.times { arr.push(rand, rand, rand, 0.0) }
+output = OutputBuffer.new(:float, arr.size)
+
+
+Benchmark.bmbm do |x|
+  x.report("cpu") { norm_all(arr) }
+  x.report("gpu") { prog.norm(output, arr, num_vecs) }
+end
+

data/benchmarks/sort.rb

@@ -0,0 +1,30 @@
+$:.unshift(File.dirname(__FILE__) + '/../ext')
+
+require 'barracuda'
+require 'benchmark'
+
+include Barracuda
+
+prog = Program.new <<-'eof'
+  __kernel sort(__global int *out, __global int *in, int total) {
+    int i, final_index = 0, extra = 0;
+    int id = get_global_id(0);
+    if (id >= total) return;
+    int my_value = in[id];
+    for (i = 0; i < total; i++) {
+      if (in[i] < my_value) final_index++;
+      if (in[i] == my_value && i < id) extra++;
+    }
+    out[final_index+extra] = my_value;
+  }
+eof
+
+max = 1000
+arr = (1..max).map { (rand * max).to_i }
+output = OutputBuffer.new(:int, arr.size)
+ 
+Benchmark.bm do |x|
+ x.report("cpu") { arr.sort }
+ x.report("gpu") { prog.sort(output, arr, arr.size) }
+end
+

data/benchmarks/to_float.rb

@@ -18,7 +18,7 @@ output = OutputBuffer.new(:float, arr.size)
  
 TIMES = 1
 Benchmark.bmbm do |x|
-  x.report("cpu") { TIMES.times { arr.map {|x| (x.to_f + 0.5) / 3.8 + 2.0 } } }
-  x.report("gpu") { TIMES.times { prog.sum(output, input, arr.size); output.clear } }
+  x.report("regular") { TIMES.times { arr.map {|x| (x.to_f + 0.5) / 3.8 + 2.0 } } }
+  x.report("opencl") { TIMES.times { prog.sum(output, input, arr.size); output.clear } }
 end
 

data/ext/barracuda.c

@@ -7,8 +7,31 @@ static VALUE rb_cOutputBuffer;
 static VALUE rb_cProgram;
 static VALUE rb_eProgramSyntaxError;
 static VALUE rb_eOpenCLError;
-
-static ID ba_worker_size;
+static VALUE rb_cType;
+static VALUE rb_hTypes;
+
+static ID id_times;
+static ID id_to_sym;
+static ID id_data_type;
+static ID id_object;
+
+static ID id_type_bool;
+static ID id_type_char;
+static ID id_type_uchar;
+static ID id_type_short;
+static ID id_type_ushort;
+static ID id_type_int;
+static ID id_type_uint;
+static ID id_type_long;
+static ID id_type_ulong;
+static ID id_type_float;
+static ID id_type_half;
+static ID id_type_double;
+static ID id_type_size_t;
+static ID id_type_ptrdiff_t;
+static ID id_type_intptr_t;
+static ID id_type_uintptr_t;
+/*static ID id_type_void;*/
 
 static VALUE program_compile(VALUE self, VALUE source);
 static VALUE buffer_data_set(VALUE self, VALUE new_value);
@@ -17,9 +40,7 @@ static cl_device_id device_id = NULL;
 static cl_context context = NULL;
 static int err;
 
-#define BUFFER_TYPE_FLOAT 0x0001
-#define BUFFER_TYPE_INT   0x0002
-#define BUFFER_TYPE_CHAR  0x0003
+#define VERSION_STRING "1.1"
 
 struct program {
     cl_program program;
@@ -31,13 +52,78 @@ struct kernel {
 
 struct buffer {
     VALUE arr;
-    unsigned int type;
+    ID type;
     size_t num_items;
     size_t member_size;
     void *cachebuf;
     cl_mem data;
 };
 
+static VALUE
+data_type_set(VALUE self, VALUE value)
+{
+    if (TYPE(value) != T_SYMBOL) {
+        value = rb_str_intern(rb_String(value));
+    }
+    if (rb_hash_aref(rb_hTypes, value) == Qnil) {
+        rb_raise(rb_eArgError, "invalid data type %s", 
+            RSTRING_PTR(rb_inspect(value)));
+    }
+    
+    rb_ivar_set(self, id_data_type, value);
+    return self;
+}
+
+static VALUE
+data_type_get(VALUE self, ID type)
+{
+    VALUE value = rb_ivar_get(self, id_data_type);
+    if (NIL_P(value)) {
+        value = ID2SYM(type);
+        data_type_set(self, value);
+    }
+    return value;
+}
+
+static VALUE
+object_data_type_get(VALUE self)
+{
+    return rb_ivar_get(self, id_data_type);
+}
+
+static VALUE
+fixnum_data_type_get(VALUE self)
+{
+    return ID2SYM(id_type_int);
+}
+
+static VALUE
+bignum_data_type_get(VALUE self)
+{
+    return data_type_get(self, id_type_long);
+}
+
+static VALUE
+float_data_type_get(VALUE self)
+{
+    return data_type_get(self, id_type_float);
+}
+
+static VALUE
+array_data_type_get(VALUE self)
+{
+    VALUE value = rb_ivar_get(self, id_data_type);
+    if (RTEST(value)) return value;
+    
+    if (RARRAY_LEN(self) > 0) {
+        VALUE value = rb_funcall(RARRAY_PTR(self)[0], id_data_type, 0);
+        if (RTEST(value)) return value;
+    }
+
+    rb_raise(rb_eRuntimeError, "unknown buffer data in array %s", 
+        RSTRING_PTR(rb_inspect(self)));
+}
+
 #define GET_PROGRAM() \
     struct program *program; \
     Data_Get_Struct(self, struct program, program);
@@ -46,28 +132,143 @@ struct buffer {
     struct buffer *buffer; \
     Data_Get_Struct(self, struct buffer, buffer);
 
+#define TYPE_SET(type, size) \
+    id_type_##type = rb_intern(#type); \
+    rb_hash_aset(rb_hTypes, ID2SYM(id_type_##type), INT2FIX(sizeof(size)));
+
+#define TYPE_TO_NATIVE(type_name, cast_type, CONVERT_FUNC) \
+    if (id_type_##type_name == data_type) { \
+        *((cast_type*)native_value) = (cast_type)CONVERT_FUNC(value); \
+        return; \
+    }
+
+#define TYPE_TO_RUBY(type_name, cast_type, CONVERT_FUNC) \
+    if (id_type_##type_name == data_type) { \
+        return CONVERT_FUNC(*((cast_type*)native_value)); \
+    }
+
 static void
-init_opencl()
+types_hash_init()
 {
-    if (device_id == NULL) {
-        err = clGetDeviceIDs(NULL, CL_DEVICE_TYPE_GPU, 1, &device_id, NULL);
-        if (err != CL_SUCCESS) {
-            rb_raise(rb_eOpenCLError, "failed to create a device group");
-        }
-    }
+    TYPE_SET(bool,      char);
+    TYPE_SET(char,      cl_char);
+    TYPE_SET(uchar,     cl_uchar);
+    TYPE_SET(short,     cl_short);
+    TYPE_SET(ushort,    cl_ushort);
+    TYPE_SET(int,       cl_int);
+    TYPE_SET(uint,      cl_uint);
+    TYPE_SET(long,      cl_long);
+    TYPE_SET(ulong,     cl_ulong);
+    TYPE_SET(float,     cl_float);
+    TYPE_SET(half,      cl_half);
+    TYPE_SET(double,    cl_double);
+    TYPE_SET(size_t,    size_t);
+    TYPE_SET(ptrdiff_t, ptrdiff_t);
+    TYPE_SET(intptr_t,  intptr_t);
+    TYPE_SET(uintptr_t, uintptr_t);
+    OBJ_FREEZE(rb_hTypes);
+}
 
-    if (context == NULL) {
-        context = clCreateContext(0, 1, &device_id, NULL, NULL, &err);
-        if (!context) {
-            rb_raise(rb_eOpenCLError, "failed to create a program context");
+static void
+type_to_native(VALUE value, ID data_type, void *native_value)
+{
+    if (id_type_char == data_type || id_type_uchar == data_type) {
+        if (TYPE(value) == T_FIXNUM) {
+            value = rb_funcall(value, rb_intern("chr"), 0);
         }
+        *((cl_char *)native_value) = RSTRING_PTR(value)[0];
+        return;
+    }
+    if (id_type_float == data_type || id_type_double == data_type) {
+        *((cl_float *)native_value) = TYPE(value) == T_FIXNUM ? 
+            (cl_float)FIX2INT(value) : RFLOAT_VALUE(value);
+        return;
+    }
+    if (id_type_half == data_type) {
+        *((cl_half *)native_value) = TYPE(value) == T_FIXNUM ? 
+            (cl_half)FIX2INT(value) : RFLOAT_VALUE(value);
+        return;
     }
+    
+    TYPE_TO_NATIVE(bool,      char,       FIX2INT);
+    TYPE_TO_NATIVE(short,     cl_short,   FIX2INT);
+    TYPE_TO_NATIVE(ushort,    cl_ushort,  NUM2UINT);
+    TYPE_TO_NATIVE(int,       cl_int,     FIX2INT);
+    TYPE_TO_NATIVE(uint,      cl_uint,    NUM2UINT);
+    TYPE_TO_NATIVE(long,      cl_long,    NUM2LONG);
+    TYPE_TO_NATIVE(ulong,     cl_ulong,   NUM2ULONG);
+    TYPE_TO_NATIVE(double,    cl_double,  NUM2DBL);
+    TYPE_TO_NATIVE(size_t,    size_t,     NUM2UINT);
+    TYPE_TO_NATIVE(ptrdiff_t, ptrdiff_t,  NUM2UINT);
+    TYPE_TO_NATIVE(intptr_t,  intptr_t,   NUM2UINT);
+    TYPE_TO_NATIVE(uintptr_t, uintptr_t,  NUM2UINT);
+}
+
+static VALUE
+type_to_ruby(void *native_value, ID data_type)
+{
+    TYPE_TO_RUBY(bool,      char,       INT2FIX);
+    TYPE_TO_RUBY(char,      cl_char,    INT2FIX);
+    TYPE_TO_RUBY(uchar,     cl_uchar,   UINT2NUM);
+    TYPE_TO_RUBY(short,     cl_short,   INT2FIX);
+    TYPE_TO_RUBY(ushort,    cl_ushort,  UINT2NUM);
+    TYPE_TO_RUBY(int,       cl_int,     INT2FIX);
+    TYPE_TO_RUBY(uint,      cl_uint,    UINT2NUM);
+    TYPE_TO_RUBY(long,      cl_long,    LONG2NUM);
+    TYPE_TO_RUBY(ulong,     cl_ulong,   ULONG2NUM);
+    TYPE_TO_RUBY(float,     cl_float,   rb_float_new);
+    TYPE_TO_RUBY(half,      cl_half,    rb_float_new);
+    TYPE_TO_RUBY(double,    cl_double,  DBL2NUM);
+    TYPE_TO_RUBY(size_t,    size_t,     UINT2NUM);
+    TYPE_TO_RUBY(ptrdiff_t, ptrdiff_t,  UINT2NUM);
+    TYPE_TO_RUBY(intptr_t,  intptr_t,   UINT2NUM);
+    TYPE_TO_RUBY(uintptr_t, uintptr_t,  UINT2NUM);
+    return Qnil;
+}
+
+static VALUE
+type_initialize(VALUE self, VALUE object)
+{
+    rb_ivar_set(self, id_object, object);
+    return self;
+}
+
+static VALUE
+type_method_missing(VALUE self, VALUE type)
+{
+    data_type_set(self, type);
+    return self;
+}
+
+static VALUE
+type_object(VALUE self)
+{
+    return rb_ivar_get(self, id_object);
+}
+
+static VALUE
+object_to_type(VALUE self, VALUE type)
+{
+    rb_ivar_set(self, id_data_type, type);
+    return self;
+}
+
+static VALUE
+fixnum_to_type(VALUE self, VALUE type)
+{
+    VALUE out = rb_funcall(rb_cType, rb_intern("new"), 1, self);
+    return type_method_missing(out, type);
+}
+
+static VALUE
+type_new(VALUE klass, VALUE type)
+{
+    return rb_funcall(rb_cType, rb_intern("new"), 1, type);
 }
 
 static void
 free_buffer(struct buffer *buffer)
 {
-    fflush(stdout);
     clReleaseMemObject(buffer->data);
     rb_gc_mark(buffer->arr);
     ruby_xfree(buffer->cachebuf);
@@ -88,26 +289,15 @@ static void
 buffer_update_cache_info(struct buffer *buffer)
 {
     buffer->num_items = RARRAY_LEN(buffer->arr);
-
-    switch (TYPE(RARRAY_PTR(buffer->arr)[0])) {
-        case T_FIXNUM:
-            buffer->type = BUFFER_TYPE_INT;
-            buffer->member_size = sizeof(int);
-            break;
-        case T_FLOAT:
-            buffer->type = BUFFER_TYPE_FLOAT;
-            buffer->member_size = sizeof(float);
-            break;
-        default:
-            rb_raise(rb_eRuntimeError, "invalid buffer data %s", 
-                RSTRING_PTR(rb_inspect(buffer->arr)));
-    }
+    buffer->type = SYM2ID(rb_funcall(buffer->arr, id_data_type, 0));
+    buffer->member_size = FIX2INT(rb_hash_aref(rb_hTypes, ID2SYM(buffer->type)));
 }
 
 static VALUE
 buffer_write(VALUE self)
 {
-    unsigned int i;
+    unsigned int i, index;
+    unsigned long data_ptr[16]; // data buffer
     
     GET_BUFFER();
     
@@ -118,22 +308,11 @@ buffer_write(VALUE self)
     }
     buffer->cachebuf = malloc(buffer->num_items * buffer->member_size);
     
-    for (i = 0; i < RARRAY_LEN(buffer->arr); i++) {
+    for (i = 0, index = 0; i < RARRAY_LEN(buffer->arr); i++, index += buffer->member_size) {
         VALUE item = RARRAY_PTR(buffer->arr)[i];
-        switch (buffer->type) {
-            case BUFFER_TYPE_INT: {
-                int value = FIX2INT(item);
-                ((int *)buffer->cachebuf)[i] = value;
-                break;
-            }
-            case BUFFER_TYPE_FLOAT: {
-                float value = RFLOAT_VALUE(item);
-                ((float *)buffer->cachebuf)[i] = value;
-                break;
-            }
-            default:
-                ((uint32_t *)buffer->cachebuf)[i] = 0;
-        }       
+        
+        type_to_native(item, buffer->type, (void *)data_ptr);
+        memcpy(((int8_t*)buffer->cachebuf) + index, (void *)data_ptr, buffer->member_size);
     }
     
     return self;
@@ -142,24 +321,16 @@ buffer_write(VALUE self)
 static VALUE
 buffer_read(VALUE self)
 {
-    unsigned int i;
+    unsigned int i, index;
     
     GET_BUFFER();
     
     rb_gc_mark(buffer->arr);
     buffer->arr = rb_ary_new2(buffer->num_items);
 
-    for (i = 0; i < buffer->num_items; i++) {
-        switch (buffer->type) {
-            case BUFFER_TYPE_INT:
-                rb_ary_push(buffer->arr, INT2FIX(((int *)buffer->cachebuf)[i]));
-                break;
-            case BUFFER_TYPE_FLOAT:
-                rb_ary_push(buffer->arr, rb_float_new(((float *)buffer->cachebuf)[i]));
-                break;
-            default:
-                rb_ary_push(buffer->arr, Qnil);
-        }       
+    for (i = 0, index = 0; i < buffer->num_items; i++, index += buffer->member_size) {
+        VALUE value = type_to_ruby(((int8_t*)buffer->cachebuf) + index, buffer->type);
+        rb_ary_push(buffer->arr, value);
     }
     
     return self;
@@ -224,25 +395,21 @@ buffer_initialize(int argc, VALUE *argv, VALUE self)
 static VALUE
 obuffer_initialize(VALUE self, VALUE type, VALUE size)
 {
+    VALUE type_sym, member_size;
     GET_BUFFER();
     
-    StringValue(type);
-    if (strcmp(RSTRING_PTR(type), "float") == 0) {
-        buffer->type = BUFFER_TYPE_FLOAT;
-        buffer->member_size = sizeof(float);
-    }
-    else if (strcmp(RSTRING_PTR(type), "int") == 0) {
-        buffer->type = BUFFER_TYPE_INT;
-        buffer->member_size = sizeof(int);
-    }
-    else {
-        rb_raise(rb_eArgError, "type can only be :float or :int");
+    type_sym = rb_funcall(type, id_to_sym, 0);
+    member_size = rb_hash_aref(rb_hTypes, type_sym);
+    if (NIL_P(member_size)) {
+        rb_raise(rb_eArgError, "type can only be one of %s", 
+            RSTRING_PTR(rb_inspect(rb_funcall(rb_hTypes, rb_intern("keys"), 0))));
     }
-    
     if (TYPE(size) != T_FIXNUM) {
         rb_raise(rb_eArgError, "expecting buffer size as argument 2");
     }
     
+    buffer->type = SYM2ID(type_sym);
+    buffer->member_size = FIX2INT(member_size);
     buffer->num_items = FIX2UINT(size);
     buffer->cachebuf = malloc(buffer->num_items * buffer->member_size);
     buffer->data = clCreateBuffer(context, CL_MEM_READ_WRITE, 
@@ -355,62 +522,79 @@ program_method_missing(int argc, VALUE *argv, VALUE self)
     
     commands = clCreateCommandQueue(context, device_id, 0, &err);
     if (!commands) {
+        clReleaseKernel(kernel);
         rb_raise(rb_eOpenCLError, "could not execute kernel method '%s'", RSTRING_PTR(argv[0]));
     }
 
     for (i = 1; i < argc; i++) {
-        err = 0;
-        if (i == argc - 1 && TYPE(argv[i]) == T_HASH) {
-            VALUE worker_size = rb_hash_aref(argv[i], ID2SYM(ba_worker_size));
+        VALUE item = argv[i];
+        err = !CL_SUCCESS;
+        
+        if (i == argc - 1 && TYPE(item) == T_HASH) {
+            VALUE worker_size = rb_hash_aref(item, ID2SYM(id_times));
             if (RTEST(worker_size) && TYPE(worker_size) == T_FIXNUM) {
                 global = FIX2UINT(worker_size);
             }
             else {
                 CLEAN();
-                rb_raise(rb_eArgError, "opts hash must be {:worker_size => INT_VALUE}, got %s",
-                    RSTRING_PTR(rb_inspect(argv[i])));
+                rb_raise(rb_eArgError, "opts hash must be {:times => INT_VALUE}, got %s",
+                    RSTRING_PTR(rb_inspect(item)));
             }
             break;
         }
         
-        switch(TYPE(argv[i])) {
-            case T_FIXNUM: {
-                int value = FIX2INT(argv[i]);
-                err = clSetKernelArg(kernel, i - 1, sizeof(int), &value);
-                break;
+        if (TYPE(item) == T_ARRAY) {
+            /* create buffer from arg */
+            VALUE buf = buffer_s_allocate(rb_cBuffer);
+            item = buffer_initialize(1, &item, buf);
+        }
+
+        if (CLASS_OF(item) == rb_cOutputBuffer) {
+            struct buffer *buffer;
+            Data_Get_Struct(item, struct buffer, buffer);
+            err = clSetKernelArg(kernel, i - 1, sizeof(cl_mem), &buffer->data);
+            if (buffer->num_items > global) {
+                global = buffer->num_items;
             }
-            case T_FLOAT: {
-                float value = RFLOAT_VALUE(argv[i]);
-                err = clSetKernelArg(kernel, i - 1, sizeof(float), &value);
-                break;
+        }
+        else if (CLASS_OF(item) == rb_cBuffer) {
+            struct buffer *buffer;
+            Data_Get_Struct(item, struct buffer, buffer);
+
+            buffer_write(item);
+            clEnqueueWriteBuffer(commands, buffer->data, CL_TRUE, 0, 
+                buffer->num_items * buffer->member_size, buffer->cachebuf, 0, NULL, NULL);
+            err = clSetKernelArg(kernel, i - 1, sizeof(cl_mem), &buffer->data);
+            if (buffer->num_items > global) {
+                global = buffer->num_items;
             }
-            case T_ARRAY: {
-                /* TODO */
-                /* fall-through */
+        }
+        else {
+            unsigned long data_ptr[16]; // a buffer of data
+            size_t data_size_t;
+            VALUE data_type, data_size;
+            
+            if (CLASS_OF(item) == rb_cType) {
+                data_type = rb_funcall(type_object(item), id_data_type, 0);
+            }
+            else {
+                data_type = rb_funcall(item, id_data_type, 0);
             }
-            default:
-                if (CLASS_OF(argv[i]) == rb_cOutputBuffer) {
-                    struct buffer *buffer;
-                    Data_Get_Struct(argv[i], struct buffer, buffer);
-                    err = clSetKernelArg(kernel, i - 1, sizeof(cl_mem), &buffer->data);
-                    if (buffer->num_items > global) {
-                        global = buffer->num_items;
-                    }
-                }
-                else if (CLASS_OF(argv[i]) == rb_cBuffer) {
-                    struct buffer *buffer;
-                    Data_Get_Struct(argv[i], struct buffer, buffer);
-
-                    buffer_write(argv[i]);
-                    clEnqueueWriteBuffer(commands, buffer->data, CL_TRUE, 0, 
-                        buffer->num_items * buffer->member_size, buffer->cachebuf, 0, NULL, NULL);
-                    err = clSetKernelArg(kernel, i - 1, sizeof(cl_mem), &buffer->data);
-                }
-                break;
+            data_size = rb_hash_aref(rb_hTypes, data_type);
+            if (NIL_P(data_size)) {
+                CLEAN();
+                rb_raise(rb_eRuntimeError, "invalid data type for %s", 
+                    RSTRING_PTR(rb_inspect(item)));
+            }
+            
+            data_size_t = FIX2UINT(data_size);
+            type_to_native(item, SYM2ID(data_type), (void *)data_ptr);
+            err = clSetKernelArg(kernel, i - 1, data_size_t, data_ptr);
         }
+
         if (err != CL_SUCCESS) {
             CLEAN();
-            rb_raise(rb_eArgError, "invalid kernel method parameter: %s", RSTRING_PTR(rb_inspect(argv[i])));
+            rb_raise(rb_eArgError, "invalid kernel method parameter: %s", RSTRING_PTR(rb_inspect(item)));
         }
     }
     
@@ -430,13 +614,14 @@ program_method_missing(int argc, VALUE *argv, VALUE self)
     clFinish(commands);
     
     for (i = 1; i < argc; i++) {
-        if (CLASS_OF(argv[i]) == rb_cOutputBuffer) {
+        VALUE item = argv[i];
+        if (CLASS_OF(item) == rb_cOutputBuffer) {
             struct buffer *buffer;
-            Data_Get_Struct(argv[i], struct buffer, buffer);
+            Data_Get_Struct(item, struct buffer, buffer);
             err = clEnqueueReadBuffer(commands, buffer->data, CL_TRUE, 0, 
                 buffer->num_items * buffer->member_size, buffer->cachebuf, 0, NULL, NULL);
             ERROR("failed to read output buffer");
-            buffer_read(argv[i]);
+            buffer_read(item);
         }
     }
 
@@ -444,12 +629,39 @@ program_method_missing(int argc, VALUE *argv, VALUE self)
     return Qnil;
 }
 
+static void
+init_opencl()
+{
+    if (device_id == NULL) {
+        err = clGetDeviceIDs(NULL, CL_DEVICE_TYPE_GPU, 1, &device_id, NULL);
+        if (err != CL_SUCCESS) {
+            rb_raise(rb_eOpenCLError, "failed to create a device group");
+        }
+    }
+
+    if (context == NULL) {
+        context = clCreateContext(0, 1, &device_id, NULL, NULL, &err);
+        if (!context) {
+            rb_raise(rb_eOpenCLError, "failed to create a program context");
+        }
+    }
+}
+
 void
 Init_barracuda()
 {
-    ba_worker_size = rb_intern("worker_size");
+    id_times = rb_intern("times");
+    id_to_sym = rb_intern("to_sym");
+    id_data_type = rb_intern("data_type");
+    id_object = rb_intern("object");
+    
+    rb_hTypes = rb_hash_new();
+    rb_define_method(rb_mKernel, "Type", type_new, 1);
+    types_hash_init();
     
     rb_mBarracuda = rb_define_module("Barracuda");
+    rb_define_const(rb_mBarracuda, "VERSION",  rb_str_new2(VERSION_STRING));
+    rb_define_const(rb_mBarracuda, "TYPES", rb_hTypes);
     
     rb_eProgramSyntaxError = rb_define_class_under(rb_mBarracuda, "SyntaxError", rb_eSyntaxError);
     rb_eOpenCLError = rb_define_class_under(rb_mBarracuda, "OpenCLError", rb_eStandardError);
@@ -476,6 +688,19 @@ Init_barracuda()
     rb_undef_method(rb_cOutputBuffer, "write");
     rb_undef_method(rb_cOutputBuffer, "size_changed");
     rb_undef_method(rb_cOutputBuffer, "data=");
-
+    
+    rb_cType = rb_define_class_under(rb_mBarracuda, "Type", rb_cObject);
+    rb_define_method(rb_cType, "initialize", type_initialize, 1);
+    rb_define_method(rb_cType, "method_missing", type_method_missing, 1);
+    rb_define_method(rb_cType, "object", type_object, 0);
+    
+    rb_define_method(rb_cObject, "to_type", object_to_type, 1);
+    rb_define_method(rb_cFixnum, "to_type", fixnum_to_type, 1);
+    rb_define_method(rb_cObject, "data_type", object_data_type_get, 0);
+    rb_define_method(rb_cArray, "data_type", array_data_type_get, 0);
+    rb_define_method(rb_cFixnum, "data_type", fixnum_data_type_get, 0);
+    rb_define_method(rb_cBignum, "data_type", bignum_data_type_get, 0);
+    rb_define_method(rb_cFloat, "data_type", float_data_type_get, 0);
+    
     init_opencl();
 }

data/test/test_barracuda.rb

@@ -5,6 +5,55 @@ require "barracuda"
 
 include Barracuda
 
+class TestDataTypes < Test::Unit::TestCase
+  def test_default_fixnum_type
+    assert_equal :int, 2.data_type
+  end
+  
+  def test_default_bignum_type
+    assert_equal :long, (2**64).data_type
+  end
+  
+  def test_default_float_type
+    assert_equal :float, 2.5.data_type
+  end
+  
+  def test_default_array_type
+    assert_equal :int, [2].data_type
+    assert_equal :float, [2.5, 2.6].data_type
+  end
+  
+  def test_set_data_type_fixnum
+    assert_equal :char, 2.to_type(:char).data_type
+    assert_equal :int, 2.data_type
+  end
+  
+  def test_set_data_type
+    [2**64, 2.5, [2]].each do |v|
+      assert_equal :char, v.to_type(:char).data_type
+    end
+  end
+  
+  def test_set_invalid_data_type
+    assert_raise(ArgumentError) { 1.to_type(:unknown) }
+  end
+  
+  def test_invalid_array_data_type
+    assert_raise(RuntimeError) { [Object.new].data_type }
+    assert_raise(RuntimeError) { ['x'].data_type }
+    assert_raise(RuntimeError) { [].data_type }
+  end
+  
+  def test_object_data_type
+    assert_nil Object.new.data_type
+  end
+  
+  def test_type_class
+    assert_equal :long, Type.new(1).long.data_type
+    assert_equal :uchar, Type(1).uchar.data_type
+  end
+end
+
 class TestBuffer < Test::Unit::TestCase
   def test_buffer_create_no_data
     assert_raise(ArgumentError) { Buffer.new }
@@ -55,18 +104,14 @@ class TestBuffer < Test::Unit::TestCase
 end
 
 class TestOutputBuffer < Test::Unit::TestCase
-  def test_create_int_output_buffer
-    b = OutputBuffer.new(:int, 5)
-    assert_equal 5, b.size
-  end
-
-  def test_create_int_output_buffer
-    b = OutputBuffer.new(:float, 5)
-    assert_equal 5, b.size
+  def test_create_output_buffer_valid_types
+    TYPES.keys.each do |type|
+      assert_nothing_raised { OutputBuffer.new(type.to_s, 5) }
+    end
   end
 
   def test_create_output_buffer_with_invalid_type
-    assert_raise(ArgumentError) { OutputBuffer.new(:char, 5) }
+    assert_raise(ArgumentError) { OutputBuffer.new(:CHAR, 5) }
   end
   
   def test_create_output_buffer_with_invalid_size
@@ -98,6 +143,46 @@ class TestProgram < Test::Unit::TestCase
     assert_raise(NoMethodError) { p.not_x_y_z }
   end
   
+  def test_program_implicit_array_buffer
+    p = Program.new <<-'eof'
+      __kernel copy(__global int *out, __global int *in, int total) {
+        int i = get_global_id(0);
+        if (i < total) out[i] = in[i] + 1;
+      }
+    eof
+    
+    out = OutputBuffer.new(:int, 3)
+    p.copy(out, [1, 2, 3], 3)
+    assert_equal [2, 3, 4], out.data
+  end
+  
+  def test_program_types
+    arr = (1..5).to_a
+    outarr = arr.map {|x| x + 1 }
+    p = Program.new
+
+    TYPES.keys.each do |type|
+      # FIXME These types are currently broken (unimplemented in opencl?)
+      next if type == :bool
+      next if type == :double
+      next if type == :size_t
+      next if type == :ptrdiff_t
+      next if type == :intptr_t
+      next if type == :uintptr_t
+
+      p.compile <<-eof
+        __kernel run(__global #{type} *out, __global #{type} *in, int total) {
+          int id = get_global_id(0);
+          if (id < total) out[id] = in[id] + 1;
+        }
+      eof
+    
+      out = OutputBuffer.new(type, arr.size)
+      p.run(out, arr.to_type(type), arr.size)
+      assert_equal({type => outarr}, {type => out.data})
+    end
+  end
+  
   def test_program_int_input_buffer
     p = Program.new <<-'eof'
       __kernel run(__global int* out, __global int* in, int total) {
@@ -128,7 +213,7 @@ class TestProgram < Test::Unit::TestCase
     assert_equal arr.map {|x| x.to_f + 0.5 }, out.data
   end
   
-  def test_program_set_worker_size
+  def test_program_set_times
     p = Program.new <<-'eof'
       __kernel sum(__global int* out, __global int* in, int total) {
         int id = get_global_id(0);
@@ -140,7 +225,7 @@ class TestProgram < Test::Unit::TestCase
     sum = arr.inject(0) {|acc, el| acc + el }
     _in = Buffer.new(arr)
     out = OutputBuffer.new(:int, 1)
-    p.sum(out, _in, arr.size, :worker_size => arr.size)
+    p.sum(out, _in, arr.size, :times => arr.size)
     assert_equal sum, out.data[0]
   end
   
@@ -160,10 +245,10 @@ class TestProgram < Test::Unit::TestCase
     assert_equal sum, out.data[0]
   end
   
-  def test_program_invalid_worker_size
+  def test_program_invalid_times
     p = Program.new("__kernel sum(int x) { }")
-    assert_raise(ArgumentError) { p.sum(:worker_size => "hello") }
-    assert_raise(ArgumentError) { p.sum(:worker => 1) }
+    assert_raise(ArgumentError) { p.sum(:times => "hello") }
+    assert_raise(ArgumentError) { p.sum(:time => 1) }
   end
   
   def test_program_invalid_args
@@ -171,4 +256,19 @@ class TestProgram < Test::Unit::TestCase
     assert_raise(ArgumentError) { p.sum(1, 2) }
     assert_raise(ArgumentError) { p.sum(1, OutputBuffer.new(:int, 1), 3) }
   end
+  
+  def test_program_vectors
+    p = Program.new <<-'eof'
+      __kernel copy_to_out(__global float4 *out, __global float4 *vec) {
+        out[0].x = vec[0].x + 0.5;
+        out[0].y = vec[0].y + 0.5;
+        out[0].z = vec[0].z + 0.5;
+        out[0].w = vec[0].w + 0.5;
+      }
+    eof
+    
+    out = OutputBuffer.new(:float, 4)
+    p.copy_to_out(out, [2.5, 2.5, 2.5, 2.5])
+    assert_equal [3, 3, 3, 3], out.data
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: barracuda
 version: !ruby/object:Gem::Version 
-  version: "1.0"
+  version: "1.1"
 platform: ruby
 authors: 
 - Loren Segal
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-30 00:00:00 -04:00
+date: 2009-09-02 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -24,6 +24,8 @@ extra_rdoc_files: []
 files: 
 - ext/barracuda.c
 - ext/extconf.rb
+- benchmarks/normalize.rb
+- benchmarks/sort.rb
 - benchmarks/to_float.rb
 - test/test_barracuda.rb
 - LICENSE