barracuda 1.0

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2009 Loren Segal
+ 
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+ 
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,163 @@
+Barracuda
+=========
+
+Written by Loren Segal in 2009.
+
+SYNOPSIS
+--------
+
+Barracuda is a Ruby wrapper library for the [OpenCL][1] architecture. OpenCL is a
+framework for multi-processor computing, most notably allowing a programmer
+to run parallel programs on a GPU, taking advantage of the many cores
+available.
+
+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
+----------
+
+As mentioned above, this library currently only supports OSX 10.6 (or an earlier
+version with the OpenCL framework, if that's even possible). If you manage to
+mess with the source and get it working on [insert system here], please submit
+your patches.
+
+Okay, assuming you have a compatible machine:
+
+    sudo gem install barracuda
+    
+Or:
+
+    git clone git://github.com/lsegal/barracuda
+    cd barracuda
+    rake install
+    
+USING
+-----
+
+The basic workflow behind the OpenCL architecture is:
+
+1. Create a program (and kernel) to be run on the GPU's many cores.
+2. Create input/output buffers to pass data from Ruby to the GPU and back.
+3. Read the output buffer(s) to get your computed data.
+
+In Barracuda, this looks basically like:
+
+1. Create a `Barracuda::Program`
+2. Create a `Barracuda::Buffer` or `Barracuda::OutputBuffer`
+2. Call the kernel method on the program with buffers as arguments
+3. Read output buffers
+
+As you can see, there are only 3 basic classes: `Program`, `Buffer` (for input
+data), and `OutputBuffer` (for output data).
+
+EXAMPLE
+-------
+
+Consider the following example to sum a bunch of integers:
+
+    program = Program.new <<-'eof'
+      __kernel sum(__global int *out, __global int *in, int total) {
+        int id = get_global_id(0);
+        if (id < total) atom_add(&out[0], in[id]); 
+      }
+    eof
+    
+    arr    = (1..65536).to_a
+    input  = Buffer.new(arr)
+    output = OutputBuffer.new(:int, 1)
+    program.sum(output, input, arr.size)
+    
+    puts "The sum is: " + output.data[0].to_s
+    
+The above example will compute the sum of integers 1 to 65536 using (at most)
+65536 parallel processes and return the result in the 1-dimensional output
+buffer (which stores integers and is of length 1). The kernel method `sum` 
+is called by calling the `#sum` method on the program object, and the 
+arguments are passed in sequentially as the output buffer, followed by the
+input data (the integers) followed by the total size of the input (since C
+does not have the concept of array size).
+
+We can also specify the work group size (the number of iterations we need
+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)
+    
+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
+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.
+
+CLASS DETAILS
+-------------
+
+**Barracuda::Program**:
+
+Represents an OpenCL program
+    
+    Program.new(PROGRAM_SOURCE)  => creates a new program
+
+    Program#compile(SOURCE)      => recompiles a program
+
+    Program#KERNEL_METHOD(*args) => runs KERNEL_METHOD in the compiled 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)
+
+**Barracuda::Buffer**:
+
+Stores data to be sent to an OpenCL kernel method
+    
+    Buffer.new(*buffer_data) => creates a new input buffer
+  
+    Buffer#data              => accessor for the buffer data
+  
+    Buffer#size_changed      => call this if the buffer.data was modified and the size changed
+      - calls Buffer#write
+  
+    Buffer#write             => call this if the buffer.data was modified (size not changed)
+      - flushes the buffer.data cache to the OpenCL internal memory buffer
+  
+    Buffer#read              => reads the cached data back into buffer.data
+      - refreshes the buffer.data cache according to the internal memory buffer
+    
+**Barracuda::OutputBuffer**:
+
+Holds a buffer for data written from the kernel method.
+    
+    OutputBuffer.new(type, size) => creates a new output buffer
+      - type can be :float or :int
+    
+    OutputBufferBuffer#data      => accessor for the buffer data
+
+    OutputBuffer#size            => returns the buffer size
+
+GLOSSARY
+--------
+
+* **Program**: an OpenCL program is generally created from a variant of C that
+  has extra domain specific keywords. A program has at least one "kernel" 
+  method, but can have many regular methods.
+
+* **Kernel**: a special "entry" method in the program that is exposed to the 
+  programmer to be called on via the OpenCL framework. A kernel method is 
+  represented by the `__kernel` keyword before the method body.
+
+* **Buffer**: memory storage which is accessible and (generally shared with the 
+  program). Buffers are usually marked with the `__global` keyword in an 
+  OpenCL program.
+
+COPYRIGHT & LICENSING
+---------------------
+
+Copyright 2009 Loren Segal, licensed under the MIT License
+
+[1]: http://en.wikipedia.ca/wiki/OpenCL "OpenCL"

data/Rakefile

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+
+WINDOWS = (PLATFORM =~ /win32|cygwin/ ? true : false) rescue false
+SUDO = WINDOWS ? '' : 'sudo'
+
+load 'barracuda.gemspec'
+Rake::GemPackageTask.new(SPEC) do |pkg|
+  pkg.gem_spec = SPEC
+  pkg.need_zip = true
+  pkg.need_tar = true
+end
+
+desc "Install the gem locally"
+task :install => :package do 
+  sh "#{SUDO} gem install pkg/#{SPEC.name}-#{SPEC.version}.gem --local"
+  sh "rm -rf pkg/#{SPEC.name}-#{SPEC.version}" unless ENV['KEEP_FILES']
+end

data/benchmarks/to_float.rb

@@ -0,0 +1,24 @@
+$:.unshift(File.dirname(__FILE__) + '/../ext')
+
+require 'barracuda'
+require 'benchmark'
+
+include Barracuda
+
+prog = Program.new <<-'eof'
+  __kernel sum(__global float *out, __global int *in, int total) {
+    int i = get_global_id(0);
+    if (i < total) out[i] = ((float)in[i] + 0.5) / 3.8 + 2.0;
+  }
+eof
+
+arr = (1..3333333).to_a
+input = Buffer.new(arr)
+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 } }
+end
+

data/ext/barracuda.c

@@ -0,0 +1,481 @@
+#include <ruby.h>
+#include <OpenCL/OpenCL.h>
+
+static VALUE rb_mBarracuda;
+static VALUE rb_cBuffer;
+static VALUE rb_cOutputBuffer;
+static VALUE rb_cProgram;
+static VALUE rb_eProgramSyntaxError;
+static VALUE rb_eOpenCLError;
+
+static ID ba_worker_size;
+
+static VALUE program_compile(VALUE self, VALUE source);
+static VALUE buffer_data_set(VALUE self, VALUE new_value);
+
+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
+
+struct program {
+    cl_program program;
+};
+
+struct kernel {
+    cl_kernel kernel;
+};
+
+struct buffer {
+    VALUE arr;
+    unsigned int type;
+    size_t num_items;
+    size_t member_size;
+    void *cachebuf;
+    cl_mem data;
+};
+
+#define GET_PROGRAM() \
+    struct program *program; \
+    Data_Get_Struct(self, struct program, program);
+    
+#define GET_BUFFER() \
+    struct buffer *buffer; \
+    Data_Get_Struct(self, struct buffer, buffer);
+
+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");
+        }
+    }
+}
+
+static void
+free_buffer(struct buffer *buffer)
+{
+    fflush(stdout);
+    clReleaseMemObject(buffer->data);
+    rb_gc_mark(buffer->arr);
+    ruby_xfree(buffer->cachebuf);
+    ruby_xfree(buffer);
+}
+
+static VALUE
+buffer_s_allocate(VALUE klass)
+{
+    struct buffer *buffer;
+    buffer = ALLOC(struct buffer);
+    MEMZERO(buffer, struct buffer, 1);
+    buffer->arr = Qnil;
+    return Data_Wrap_Struct(klass, 0, free_buffer, buffer);
+}
+
+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)));
+    }
+}
+
+static VALUE
+buffer_write(VALUE self)
+{
+    unsigned int i;
+    
+    GET_BUFFER();
+    
+    buffer_update_cache_info(buffer);
+    
+    if (buffer->cachebuf) {
+        xfree(buffer->cachebuf);
+    }
+    buffer->cachebuf = malloc(buffer->num_items * buffer->member_size);
+    
+    for (i = 0; i < RARRAY_LEN(buffer->arr); i++) {
+        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;
+        }       
+    }
+    
+    return self;
+}
+
+static VALUE
+buffer_read(VALUE self)
+{
+    unsigned int i;
+    
+    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);
+        }       
+    }
+    
+    return self;
+}
+
+static VALUE
+buffer_size_changed(VALUE self)
+{
+    GET_BUFFER();
+    
+    if (buffer->data) {
+        clReleaseMemObject(buffer->data);
+    }
+    buffer_update_cache_info(buffer);
+    buffer->data = clCreateBuffer(context, CL_MEM_READ_WRITE, 
+        buffer->num_items * buffer->member_size, NULL, NULL);
+
+    buffer_write(self);
+    
+    return self;
+}
+
+static VALUE
+buffer_data(VALUE self)
+{
+    GET_BUFFER();
+    return buffer->arr;
+}
+
+static VALUE
+buffer_data_set(VALUE self, VALUE new_value)
+{
+    GET_BUFFER();
+    
+    if (RTEST(buffer->arr)) {
+        rb_gc_mark(buffer->arr);
+    }
+    buffer->arr = new_value;
+    buffer_size_changed(self);
+    return buffer->arr;
+}
+
+static VALUE
+buffer_initialize(int argc, VALUE *argv, VALUE self)
+{
+    GET_BUFFER();
+    
+    if (argc == 0) {
+        rb_raise(rb_eArgError, "no buffer data given");
+    }
+    
+    if (TYPE(argv[0]) == T_ARRAY) {
+        buffer_data_set(self, argv[0]);
+    }
+    else {
+        buffer_data_set(self, rb_ary_new4(argc, argv));
+    }
+    
+    return self;
+}
+
+static VALUE
+obuffer_initialize(VALUE self, VALUE type, VALUE 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");
+    }
+    
+    if (TYPE(size) != T_FIXNUM) {
+        rb_raise(rb_eArgError, "expecting buffer size as argument 2");
+    }
+    
+    buffer->num_items = FIX2UINT(size);
+    buffer->cachebuf = malloc(buffer->num_items * buffer->member_size);
+    buffer->data = clCreateBuffer(context, CL_MEM_READ_WRITE, 
+        buffer->member_size * buffer->num_items, NULL, NULL);
+    
+    return self;
+}
+
+static VALUE
+obuffer_clear(VALUE self)
+{
+    GET_BUFFER();
+    memset(buffer->cachebuf, 0, buffer->member_size * buffer->num_items);
+    return self;
+}
+
+static VALUE
+obuffer_size(VALUE self)
+{
+    GET_BUFFER();
+    return INT2FIX(buffer->num_items);
+}
+
+static void
+free_program(struct program *program)
+{
+    clReleaseProgram(program->program);
+    xfree(program);
+}
+
+static VALUE
+program_s_allocate(VALUE klass)
+{
+    struct program *program;
+    program = ALLOC(struct program);
+    MEMZERO(program, struct program, 1);
+    return Data_Wrap_Struct(klass, 0, free_program, program);
+}
+
+static VALUE
+program_initialize(int argc, VALUE *argv, VALUE self)
+{
+    VALUE source;
+    
+    rb_scan_args(argc, argv, "01", &source);
+    if (source != Qnil) {
+        program_compile(self, source);
+    }
+    
+    return self;
+}
+
+static VALUE
+program_compile(VALUE self, VALUE source)
+{
+    const char *c_source;
+    GET_PROGRAM();
+    StringValue(source);
+    
+    if (program->program) {
+        clReleaseProgram(program->program);
+        program->program = 0;
+    }
+    
+    c_source = StringValueCStr(source);
+    program->program = clCreateProgramWithSource(context, 1, &c_source, NULL, &err);
+    if (!program->program) {
+        program->program = 0;
+        rb_raise(rb_eOpenCLError, "failed to create compute program");
+    }
+
+    err = clBuildProgram(program->program, 0, NULL, NULL, NULL, NULL);
+    if (err != CL_SUCCESS) {
+        size_t len;
+        char buffer[2048];
+
+        clGetProgramBuildInfo(program->program, device_id, CL_PROGRAM_BUILD_LOG, sizeof(buffer), buffer, &len);
+        clReleaseProgram(program->program);
+        program->program = 0;
+        rb_raise(rb_eProgramSyntaxError, "%s", buffer);
+    }
+    
+    return Qtrue;
+}
+
+#define CLEAN() program_clean(kernel, commands);
+#define ERROR(msg) if (err != CL_SUCCESS) { CLEAN(); rb_raise(rb_eOpenCLError, msg); }
+
+static void
+program_clean(cl_kernel kernel, cl_command_queue commands)
+{
+    clReleaseKernel(kernel);
+    clReleaseCommandQueue(commands);
+}
+
+static VALUE
+program_method_missing(int argc, VALUE *argv, VALUE self)
+{
+    int i;
+    size_t local = 0, global = 0;
+    cl_kernel kernel;
+    cl_command_queue commands;
+    GET_PROGRAM();
+    
+    StringValue(argv[0]);
+    kernel = clCreateKernel(program->program, RSTRING_PTR(argv[0]), &err);
+    if (!kernel || err != CL_SUCCESS) {
+        rb_raise(rb_eNoMethodError, "no kernel method '%s'", RSTRING_PTR(argv[0]));
+    }
+    
+    commands = clCreateCommandQueue(context, device_id, 0, &err);
+    if (!commands) {
+        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));
+            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])));
+            }
+            break;
+        }
+        
+        switch(TYPE(argv[i])) {
+            case T_FIXNUM: {
+                int value = FIX2INT(argv[i]);
+                err = clSetKernelArg(kernel, i - 1, sizeof(int), &value);
+                break;
+            }
+            case T_FLOAT: {
+                float value = RFLOAT_VALUE(argv[i]);
+                err = clSetKernelArg(kernel, i - 1, sizeof(float), &value);
+                break;
+            }
+            case T_ARRAY: {
+                /* TODO */
+                /* fall-through */
+            }
+            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;
+        }
+        if (err != CL_SUCCESS) {
+            CLEAN();
+            rb_raise(rb_eArgError, "invalid kernel method parameter: %s", RSTRING_PTR(rb_inspect(argv[i])));
+        }
+    }
+    
+    err = clGetKernelWorkGroupInfo(kernel, device_id, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &local, NULL);
+    ERROR("failed to retrieve kernel work group info");
+    
+    { /* global work size must be power of 2, greater than 3 and not smaller than local */
+        size_t size = 4;
+        while (size < global) size *= 2;
+        global = size;
+        if (global < local) global = local;
+    }
+
+    clEnqueueNDRangeKernel(commands, kernel, 1, NULL, &global, &local, 0, NULL, NULL);
+    if (err) { CLEAN(); rb_raise(rb_eOpenCLError, "failed to execute kernel method"); }
+    
+    clFinish(commands);
+    
+    for (i = 1; i < argc; i++) {
+        if (CLASS_OF(argv[i]) == rb_cOutputBuffer) {
+            struct buffer *buffer;
+            Data_Get_Struct(argv[i], 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]);
+        }
+    }
+
+    CLEAN();
+    return Qnil;
+}
+
+void
+Init_barracuda()
+{
+    ba_worker_size = rb_intern("worker_size");
+    
+    rb_mBarracuda = rb_define_module("Barracuda");
+    
+    rb_eProgramSyntaxError = rb_define_class_under(rb_mBarracuda, "SyntaxError", rb_eSyntaxError);
+    rb_eOpenCLError = rb_define_class_under(rb_mBarracuda, "OpenCLError", rb_eStandardError);
+    
+    rb_cProgram = rb_define_class_under(rb_mBarracuda, "Program", rb_cObject);
+    rb_define_alloc_func(rb_cProgram, program_s_allocate);
+    rb_define_method(rb_cProgram, "initialize", program_initialize, -1);
+    rb_define_method(rb_cProgram, "compile", program_compile, 1);
+    rb_define_method(rb_cProgram, "method_missing", program_method_missing, -1);
+
+    rb_cBuffer = rb_define_class_under(rb_mBarracuda, "Buffer", rb_cObject);
+    rb_define_alloc_func(rb_cBuffer, buffer_s_allocate);
+    rb_define_method(rb_cBuffer, "initialize", buffer_initialize, -1);
+    rb_define_method(rb_cBuffer, "size_changed", buffer_size_changed, 0);
+    rb_define_method(rb_cBuffer, "read", buffer_read, 0);
+    rb_define_method(rb_cBuffer, "write", buffer_write, 0);
+    rb_define_method(rb_cBuffer, "data", buffer_data, 0);
+    rb_define_method(rb_cBuffer, "data=", buffer_data_set, 1);
+
+    rb_cOutputBuffer = rb_define_class_under(rb_mBarracuda, "OutputBuffer", rb_cBuffer);
+    rb_define_method(rb_cOutputBuffer, "initialize", obuffer_initialize, 2);
+    rb_define_method(rb_cOutputBuffer, "size", obuffer_size, 0);
+    rb_define_method(rb_cOutputBuffer, "clear", obuffer_clear, 0);
+    rb_undef_method(rb_cOutputBuffer, "write");
+    rb_undef_method(rb_cOutputBuffer, "size_changed");
+    rb_undef_method(rb_cOutputBuffer, "data=");
+
+    init_opencl();
+}

data/ext/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+$CPPFLAGS += " -DRUBY_19" if RUBY_VERSION =~ /1.9/
+$LDFLAGS += " -framework OpenCL" if RUBY_PLATFORM =~ /darwin/
+create_makefile('barracuda')

data/test/test_barracuda.rb

@@ -0,0 +1,174 @@
+$:.unshift(File.dirname(__FILE__) + '/../ext/')
+
+require "test/unit"
+require "barracuda"
+
+include Barracuda
+
+class TestBuffer < Test::Unit::TestCase
+  def test_buffer_create_no_data
+    assert_raise(ArgumentError) { Buffer.new }
+  end
+  
+  def test_buffer_create_invalid_data
+    assert_raise(RuntimeError) { Buffer.new("xyz") }
+  end
+  
+  def test_buffer_create_with_array
+    b = Buffer.new([1, 2, 3, 4, 5])
+    assert_equal [1, 2, 3, 4, 5], b.data
+  end
+  
+  def test_buffer_create_with_splat
+    b = Buffer.new(1.0, 2.0, 3.0)
+    assert_equal [1.0, 2.0, 3.0], b.data
+  end
+  
+  def test_buffer_set_data
+    b = Buffer.new(1)
+    b.data = [1, 2, 3]
+    assert_equal 3, b.data.size
+  end
+  
+  def test_buffer_read
+    b = Buffer.new(4, 2, 3)
+    b.data[0] = 1
+    b.read
+    assert_equal [4,2,3], b.data
+  end
+  
+  def test_buffer_write
+    b = Buffer.new(1, 2, 3)
+    b.data[0] = 4
+    b.write
+    b.read
+    assert_equal [4,2,3], b.data
+  end
+
+  def test_buffer_size_changed
+    b = Buffer.new(1, 2, 3)
+    b.data << 4
+    b.size_changed
+    b.read
+    assert_equal [1,2,3,4], b.data
+  end
+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
+  end
+
+  def test_create_output_buffer_with_invalid_type
+    assert_raise(ArgumentError) { OutputBuffer.new(:char, 5) }
+  end
+  
+  def test_create_output_buffer_with_invalid_size
+    assert_raise(ArgumentError) { OutputBuffer.new(:int, 'x') }
+  end
+end
+
+class TestProgram < Test::Unit::TestCase
+  def test_program_create_invalid_code
+    assert_raise(Barracuda::SyntaxError) { Program.new "fib { SYNTAXERROR }" }
+  end
+  
+  def test_program_create
+    assert_nothing_raised { Program.new "__kernel fib(int x) { return 0; }"}
+  end
+  
+  def test_program_compile
+    p = Program.new
+    assert_nothing_raised { p.compile "__kernel fib(int x) { }" }
+  end
+  
+  def test_kernel_run
+    p = Program.new("__kernel x_y_z(int x) { }")
+    assert_nothing_raised { p.x_y_z }
+  end
+  
+  def test_kernel_missing
+    p = Program.new("__kernel x_y_z(int x) { }")
+    assert_raise(NoMethodError) { p.not_x_y_z }
+  end
+  
+  def test_program_int_input_buffer
+    p = Program.new <<-'eof'
+      __kernel run(__global int* out, __global int* in, int total) {
+        int id = get_global_id(0);
+        if (id < total) out[id] = in[id] + 1; 
+      }
+    eof
+    
+    arr = (1..256).to_a
+    _in = Buffer.new(arr)
+    out = OutputBuffer.new(:int, arr.size)
+    p.run(out, _in, arr.size)
+    assert_equal arr.map {|x| x + 1 }, out.data
+  end
+  
+  def test_program_float_buffer
+    p = Program.new <<-'eof'
+      __kernel run(__global float* out, __global int* in, int total) {
+        int id = get_global_id(0);
+        if (id < total) out[id] = (float)in[id] + 0.5; 
+      }
+    eof
+    
+    arr = (1..256).to_a
+    _in = Buffer.new(arr)
+    out = OutputBuffer.new(:float, arr.size)
+    p.run(out, _in, arr.size)
+    assert_equal arr.map {|x| x.to_f + 0.5 }, out.data
+  end
+  
+  def test_program_set_worker_size
+    p = Program.new <<-'eof'
+      __kernel sum(__global int* out, __global int* in, int total) {
+        int id = get_global_id(0);
+        if (id < total) atom_add(&out[0], in[id]); 
+      }
+    eof
+    
+    arr = (1..517).to_a
+    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)
+    assert_equal sum, out.data[0]
+  end
+  
+  def test_program_largest_buffer_is_input
+    p = Program.new <<-'eof'
+      __kernel sum(__global int* out, __global int* in, int total) {
+        int id = get_global_id(0);
+        if (id < total) atom_add(&out[0], in[id]); 
+      }
+    eof
+    
+    arr = (1..517).to_a
+    sum = arr.inject(0) {|acc, el| acc + el }
+    _in = Buffer.new(arr)
+    out = OutputBuffer.new(:int, 1)
+    p.sum(out, _in, arr.size)
+    assert_equal sum, out.data[0]
+  end
+  
+  def test_program_invalid_worker_size
+    p = Program.new("__kernel sum(int x) { }")
+    assert_raise(ArgumentError) { p.sum(:worker_size => "hello") }
+    assert_raise(ArgumentError) { p.sum(:worker => 1) }
+  end
+  
+  def test_program_invalid_args
+    p = Program.new("__kernel sum(int x, __global int *y) { }")
+    assert_raise(ArgumentError) { p.sum(1, 2) }
+    assert_raise(ArgumentError) { p.sum(1, OutputBuffer.new(:int, 1), 3) }
+  end
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification 
+name: barracuda
+version: !ruby/object:Gem::Version 
+  version: "1.0"
+platform: ruby
+authors: 
+- Loren Segal
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-30 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: 
+email: lsegal@soen.ca
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- ext/barracuda.c
+- ext/extconf.rb
+- benchmarks/to_float.rb
+- test/test_barracuda.rb
+- LICENSE
+- README.md
+- Rakefile
+has_rdoc: true
+homepage: http://github.com/lsegal/barracuda
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: barracuda
+rubygems_version: 1.3.4
+signing_key: 
+specification_version: 3
+summary: Barracuda is a wrapper library for OpenCL/CUDA GPGPU programming
+test_files: 
+- test/test_barracuda.rb