barracuda 1.2 → 1.3

data/README.md

@@ -33,7 +33,7 @@ Or:
     cd barracuda
     rake install
     
-USING
+USAGE
 -----
 
 The basic workflow behind the OpenCL architecture is:
@@ -45,12 +45,14 @@ The basic workflow behind the OpenCL architecture is:
 In Barracuda, this looks basically like:
 
 1. Create a `Barracuda::Program`
-2. Create a `Barracuda::Buffer` or `Barracuda::OutputBuffer`
+2. Create a `Barracuda::Buffer` for input and output
 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).
+As you can see, there are only 2 basic classes: `Program` and `Buffer`. The
+program is where you compile your OpenCL code, and the Buffer class is a 
+subclass of Array that contains your data to pass in and out of the kernel
+method.
 
 EXAMPLE
 -------
@@ -63,7 +65,7 @@ Consider the following example to sum a bunch of integers:
       }
     eof
     
-    output = OutputBuffer.new(:int, 1)
+    output = Buffer.new(1)
     program.sum((1..65536).to_a, output)
     
     puts "The sum is: " + output.data[0].to_s
@@ -72,9 +74,8 @@ 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).
+arguments are passed in sequentially as the input data (the integers) 
+followed by the output buffer to store the data.
 
 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 
@@ -83,6 +84,49 @@ manually specify the work group size, call the kernel with an options hash:
 
     program.my_kernel_method(..., :times => 512)
     
+OUTPUT BUFFERS
+--------------
+
+The Buffer class is a superset of both data to be sent and read from the OpenCL
+kernel method being called. In general, if the Buffer contains nil elements,
+it is marked as an "output buffer" and the data is read back from OpenCL after
+the kernel method executes. These nil buffers are not written to OpenCL initially,
+so they are only meant for output data. On the other hand, if the buffer contains
+regular data, it is by default considered as input data only, and the data
+is not read back after the kernel method completes.
+
+In some cases you may want to have a buffer that is both input and output and
+should be read from after the kernel method finishes. To do this, you mark the
+buffer as an `outvar` as so:
+
+    program = Program.new <<-'eof'
+      __kernel addN(__global int *data, int N) {
+        int i = get_global_id(0);
+        data[i] = data[i] + N;
+      }
+    eof
+    
+    data = [1, 2, 3]
+    program.addN(data.outvar, 10) 
+    
+    # prints: [11, 12, 13]
+    p data 
+
+RETURN VALUE
+------------
+
+Generally you need to pass in your output buffer as the buffer to write the
+data back to. The idiom `void method(input, output)` is common to write data to
+output buffers in languages such as C but is a rather clunky API for Ruby.
+Instead, Barracuda returns the output buffers as the result of the kernel method 
+call. If there is only one output buffer, that buffer is returned as a single 
+result (rather than an array of buffers). 
+
+The example above could be simply rewritten as:
+
+    # prints: [11, 12, 13]
+    p program.addN(data.outvar, 10)
+
 CONVERTING TYPES
 ----------------
 
@@ -105,6 +149,8 @@ For example, to pass in a short, do:
 This can also be applied to an Array of shorts:
 
     program.my_kernel([1, 2, 3].to_type(:short))
+    
+The default type for an array (and buffers) is :int
 
 CLASS DETAILS
 -------------
@@ -123,34 +169,21 @@ Represents an OpenCL program
       - if the last arg is a Hash, it should be an options hash with keys:
           - :times => FIXNUM (the number of iterations to run)
 
-**Barracuda::Buffer**:
+**Barracuda::Buffer** (extends *Array*):
 
-Stores data to be sent to an OpenCL kernel method
+Data storage to transfer to/from 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.new(buffer_array) => creates a new input buffer
+    Buffer.new(size)         => creates a new output buffer of size `size`
   
-    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**:
+    Buffer#mark_dirty        => call this if the data was modified between calls
 
-Holds a buffer for data written from the kernel method.
+    Buffer#dirty?            => returns whether the buffer is marked as dirty
     
-    OutputBuffer.new(type, size) => creates a new output buffer
-      - type can be :float or :int
+    Buffer#outvar            => mark the buffer to be read as output
+    
+    Buffer#outvar?           => returns whether buffer is marked to be read
     
-    OutputBufferBuffer#data      => accessor for the buffer data
-
-    OutputBuffer#size            => returns the buffer size
-
 GLOSSARY
 --------
 

data/Rakefile

@@ -1,9 +1,15 @@
 require 'rubygems'
 require 'rake/gempackagetask'
+require 'rake/testtask'
 
 WINDOWS = (PLATFORM =~ /win32|cygwin/ ? true : false) rescue false
 SUDO = WINDOWS ? '' : 'sudo'
 
+task :default => :test
+task :test => :build
+
+Rake::TestTask.new
+
 load 'barracuda.gemspec'
 Rake::GemPackageTask.new(SPEC) do |pkg|
   pkg.gem_spec = SPEC
@@ -16,3 +22,8 @@ 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
+
+desc 'Build Barracuda'
+task :build do
+  sh "cd ext && make"
+end

data/benchmarks/normalize.rb

@@ -34,7 +34,7 @@ eof
 num_vecs = 1000000
 arr = []
 num_vecs.times { arr.push(rand, rand, rand, 0.0) }
-output = OutputBuffer.new(:float, arr.size)
+output = Buffer.new(arr.size).to_type(:float)
 
 Benchmark.bmbm do |x|
   x.report("cpu") { norm_all(arr) }

data/benchmarks/to_float.rb

@@ -12,9 +12,9 @@ prog = Program.new <<-'eof'
   }
 eof
 
-arr = (1..3333333).to_a
+arr = (1..333333).to_a
 input = Buffer.new(arr)
-output = OutputBuffer.new(:float, arr.size)
+output = Buffer.new(arr.size).to_type(:float)
  
 Benchmark.bmbm do |x|
   x.report("regular") { arr.map {|x| (x.to_f + 0.5) / 3.8 + 2.0 } }

data/ext/barracuda.c

@@ -4,7 +4,6 @@
 
 static VALUE rb_mBarracuda;
 static VALUE rb_cBuffer;
-static VALUE rb_cOutputBuffer;
 static VALUE rb_cProgram;
 static VALUE rb_eProgramSyntaxError;
 static VALUE rb_eOpenCLError;
@@ -13,8 +12,10 @@ static VALUE rb_hTypes;
 
 static ID id_times;
 static ID id_to_sym;
-static ID id_data_type;
+static ID id_new;
 static ID id_object;
+static ID id_data_type;
+static ID id_buffer_data;
 
 static ID id_type_bool;
 static ID id_type_char;
@@ -35,25 +36,25 @@ 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);
 
 static cl_device_id device_id = NULL;
 static cl_context context = NULL;
 static size_t max_work_group_size = 65535;
 static int err;
 
-#define VERSION_STRING "1.2"
+#define VERSION_STRING "1.3"
 
 struct program {
     cl_program program;
 };
 
 struct buffer {
-    VALUE arr;
+    VALUE dirty;
+    VALUE outvar;
     ID type;
-    size_t num_items;
     size_t member_size;
-    void *cachebuf;
+    size_t num_items;
+    int8_t *cachebuf;
     cl_mem data;
 };
 
@@ -114,11 +115,12 @@ array_data_type_get(VALUE self)
     if (RTEST(value)) return value;
     
     if (RARRAY_LEN(self) > 0) {
+        if (NIL_P(RARRAY_PTR(self)[0])) return ID2SYM(id_type_int);
         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", 
+    
+    rb_raise(rb_eTypeError, "unknown buffer data %s", 
         RSTRING_PTR(rb_inspect(self)));
 }
 
@@ -128,7 +130,7 @@ array_data_type_get(VALUE self)
     
 #define GET_BUFFER() \
     struct buffer *buffer; \
-    Data_Get_Struct(self, struct buffer, buffer);
+    Data_Get_Struct(rb_ivar_get(self, id_buffer_data), struct buffer, buffer);
 
 #define TYPE_SET(type, size) \
     id_type_##type = rb_intern(#type); \
@@ -159,11 +161,11 @@ types_hash_init()
     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);
+    TYPE_SET(double,    cl_float);
+    TYPE_SET(size_t,    cl_uint);
+    TYPE_SET(ptrdiff_t, cl_uint);
+    TYPE_SET(intptr_t,  cl_uint);
+    TYPE_SET(uintptr_t, cl_uint);
     OBJ_FREEZE(rb_hTypes);
 }
 
@@ -195,11 +197,10 @@ type_to_native(VALUE value, ID data_type, void *native_value)
     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);
+    TYPE_TO_NATIVE(size_t,    cl_uint,    NUM2UINT);
+    TYPE_TO_NATIVE(ptrdiff_t, cl_uint,    NUM2UINT);
+    TYPE_TO_NATIVE(intptr_t,  cl_uint,    NUM2UINT);
+    TYPE_TO_NATIVE(uintptr_t, cl_uint,    NUM2UINT);
 }
 
 static VALUE
@@ -216,11 +217,11 @@ type_to_ruby(void *native_value, ID data_type)
     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);
+    TYPE_TO_RUBY(double,    cl_float,   rb_float_new);
+    TYPE_TO_RUBY(size_t,    cl_uint,    UINT2NUM);
+    TYPE_TO_RUBY(ptrdiff_t, cl_uint,    UINT2NUM);
+    TYPE_TO_RUBY(intptr_t,  cl_uint,    UINT2NUM);
+    TYPE_TO_RUBY(uintptr_t, cl_uint,    UINT2NUM);
     return Qnil;
 }
 
@@ -261,172 +262,172 @@ fixnum_to_type(VALUE self, VALUE type)
 static VALUE
 type_new(VALUE klass, VALUE type)
 {
-    return rb_funcall(rb_cType, rb_intern("new"), 1, type);
+    return rb_funcall(rb_cType, id_new, 1, type);
 }
 
 static void
-free_buffer(struct buffer *buffer)
+free_buffer_data(struct buffer *buffer)
 {
     clReleaseMemObject(buffer->data);
-    rb_gc_mark(buffer->arr);
     ruby_xfree(buffer->cachebuf);
-    ruby_xfree(buffer);
 }
 
 static VALUE
-buffer_s_allocate(VALUE klass)
+buffer_outvar(VALUE self)
 {
-    struct buffer *buffer;
-    buffer = ALLOC(struct buffer);
-    MEMZERO(buffer, struct buffer, 1);
-    buffer->arr = Qnil;
-    return Data_Wrap_Struct(klass, 0, free_buffer, buffer);
+    GET_BUFFER();
+    buffer->outvar = Qtrue;
+    return self;
 }
 
-static void
-buffer_update_cache_info(struct buffer *buffer)
+static VALUE
+buffer_is_outvar(VALUE self)
 {
-    buffer->num_items = RARRAY_LEN(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)));
+    GET_BUFFER();
+    return buffer->outvar;
 }
 
 static VALUE
-buffer_write(VALUE self)
+buffer_dirty(VALUE self)
 {
-    unsigned int i, index;
-    unsigned long data_ptr[16]; // data buffer
-    
     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, index = 0; i < RARRAY_LEN(buffer->arr); i++, index += buffer->member_size) {
-        VALUE item = RARRAY_PTR(buffer->arr)[i];
-        
-        type_to_native(item, buffer->type, (void *)data_ptr);
-        memcpy(((int8_t*)buffer->cachebuf) + index, (void *)data_ptr, buffer->member_size);
-    }
-    
-    return self;
+    if (buffer->dirty == Qtrue) return Qtrue;
+    if (buffer->data == NULL) return Qtrue;
+    if (buffer->cachebuf == NULL) return Qtrue;
+    if (RARRAY_LEN(self) != buffer->num_items) return Qtrue;
+    if (SYM2ID(rb_funcall(self, id_data_type, 0)) != buffer->type) return Qtrue;
+    return Qfalse;
 }
 
 static VALUE
-buffer_read(VALUE self)
+buffer_mark_dirty(VALUE self)
 {
-    unsigned int i, index;
-    
     GET_BUFFER();
-    
-    rb_gc_mark(buffer->arr);
-    buffer->arr = rb_ary_new2(buffer->num_items);
-
-    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;
+    return (buffer->dirty = Qtrue);
 }
 
-static VALUE
-buffer_size_changed(VALUE self)
+static void
+buffer_size_changed(struct buffer *buffer)
 {
-    GET_BUFFER();
-    
-    if (buffer->data) {
-        clReleaseMemObject(buffer->data);
-    }
-    buffer_update_cache_info(buffer);
+    clReleaseMemObject(buffer->data);
     buffer->data = clCreateBuffer(context, CL_MEM_READ_WRITE, 
-        buffer->num_items * buffer->member_size, NULL, NULL);
-
-    buffer_write(self);
-    
-    return self;
+            buffer->num_items * buffer->member_size, NULL, NULL);
+    ruby_xfree(buffer->cachebuf);
+    buffer->cachebuf = ruby_xmalloc(buffer->num_items * buffer->member_size);
 }
 
 static VALUE
-buffer_data(VALUE self)
+buffer_update_cache(VALUE self)
 {
     GET_BUFFER();
-    return buffer->arr;
+
+    if (buffer_dirty(self) == Qtrue) {
+        size_t old_num_items = buffer->num_items;
+        buffer->num_items = RARRAY_LEN(self);
+        buffer->type = SYM2ID(rb_funcall(self, id_data_type, 0));
+        buffer->member_size = FIX2INT(rb_hash_aref(rb_hTypes, ID2SYM(buffer->type)));
+        if (buffer->num_items != old_num_items) buffer_size_changed(buffer);
+        buffer->dirty = Qfalse;
+        return Qtrue;
+    }
+    
+    return Qnil;
 }
 
-static VALUE
-buffer_data_set(VALUE self, VALUE new_value)
+static void
+print_buffer(struct buffer *buffer)
 {
-    GET_BUFFER();
-    
-    if (RTEST(buffer->arr)) {
-        rb_gc_mark(buffer->arr);
+    int i;
+    for (i = 0; i < buffer->num_items * buffer->member_size; i++) {
+        int c = (int)buffer->cachebuf[i];
+        if (i > 0 && i % 8 == 0) printf("\n");
+        printf("%2.2x ", c);
     }
-    buffer->arr = new_value;
-    buffer_size_changed(self);
-    return buffer->arr;
+    printf("\n");
+    fflush(stdout);
 }
 
 static VALUE
-buffer_initialize(int argc, VALUE *argv, VALUE self)
+buffer_write(VALUE self, cl_command_queue queue)
 {
-    if (argc == 0) {
-        rb_raise(rb_eArgError, "no buffer data given");
-    }
+    unsigned int i, index;
+    unsigned long data_ptr[16]; // data buffer
     
-    if (TYPE(argv[0]) == T_ARRAY) {
-        buffer_data_set(self, argv[0]);
+    GET_BUFFER();
+
+    if (NIL_P(RARRAY_PTR(self)[0])) return Qnil;
+    
+    for (i = 0, index = 0; i < buffer->num_items; i++, index += buffer->member_size) {
+        VALUE item = RARRAY_PTR(self)[i];
+        type_to_native(item, buffer->type, data_ptr);
+        memcpy(buffer->cachebuf + index, data_ptr, buffer->member_size);
     }
-    else {
-        buffer_data_set(self, rb_ary_new4(argc, argv));
+    
+    if (queue != NULL) {
+        clEnqueueWriteBuffer(queue, buffer->data, CL_TRUE, 0, 
+            buffer->num_items * buffer->member_size, buffer->cachebuf, 0, NULL, NULL);
     }
     
     return self;
 }
 
 static VALUE
-obuffer_initialize(VALUE self, VALUE type, VALUE size)
+buffer_read(VALUE self, cl_command_queue queue)
 {
-    VALUE type_sym, member_size;
+    unsigned int i, index;
+    
     GET_BUFFER();
     
-    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");
+    if (buffer->outvar != Qtrue) return Qnil;
+
+    if (queue != NULL) {
+        clEnqueueReadBuffer(queue, buffer->data, CL_TRUE, 0, 
+            buffer->num_items * buffer->member_size, buffer->cachebuf, 0, NULL, NULL);
     }
     
-    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, 
-        buffer->member_size * buffer->num_items, NULL, NULL);
+    for (i = 0, index = 0; i < buffer->num_items; i++, index += buffer->member_size) {
+        VALUE value = type_to_ruby(buffer->cachebuf + index, buffer->type);
+        rb_ary_store(self, i, value);
+    }
     
     return self;
 }
 
 static VALUE
-obuffer_clear(VALUE self)
+array_to_outvar(VALUE self)
 {
-    GET_BUFFER();
-    memset(buffer->cachebuf, 0, buffer->member_size * buffer->num_items);
-    return self;
+    VALUE buf = rb_funcall(rb_cBuffer, id_new, 0);
+    rb_ary_replace(buf, self);
+    buffer_outvar(buf);
+    buffer_mark_dirty(buf);
+    return buf;
 }
 
 static VALUE
-obuffer_size(VALUE self)
+buffer_initialize(int argc, VALUE *argv, VALUE self)
 {
-    GET_BUFFER();
-    return INT2FIX(buffer->num_items);
+    VALUE buf_value;
+    struct buffer *buffer;
+    
+    rb_call_super(argc, argv);
+    
+    if (argc == 1 && TYPE(argv[0]) == T_ARRAY) {
+        VALUE value = rb_ivar_get(argv[0], id_data_type);
+        if (RTEST(value)) rb_ivar_set(self, id_data_type, value);
+    }
+
+    buffer = ALLOC(struct buffer);
+    MEMZERO(buffer, struct buffer, 1);
+    buffer->outvar = Qfalse;
+    buffer->dirty = Qtrue;
+    buf_value = Data_Wrap_Struct(rb_cObject, 0, free_buffer_data, buffer);
+    rb_ivar_set(self, id_buffer_data, buf_value);
+
+    if (RARRAY_LEN(self) > 0 && NIL_P(RARRAY_PTR(self)[0])) { /* outvar */
+        buffer->outvar = Qtrue;
+    }
+    
+    return self;
 }
 
 static void
@@ -500,6 +501,7 @@ program_method_missing(int argc, VALUE *argv, VALUE self)
     size_t global[3] = {1, 1, 1}, local;
     cl_kernel kernel;
     cl_command_queue commands;
+    VALUE result;
     GET_PROGRAM();
     
     StringValue(argv[0]);
@@ -531,30 +533,20 @@ program_method_missing(int argc, VALUE *argv, VALUE self)
             break;
         }
         
-        if (TYPE(item) == T_ARRAY) {
+        if (CLASS_OF(item) == rb_cArray) {
             /* create buffer from arg */
-            VALUE buf = buffer_s_allocate(rb_cBuffer);
-            item = buffer_initialize(1, &item, buf);
+            argv[i] = item = rb_funcall(rb_cBuffer, id_new, 1, item);
         }
 
-        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[0]) {
-                global[0] = buffer->num_items;
-            }
-        }
-        else if (CLASS_OF(item) == rb_cBuffer) {
+        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);
+            Data_Get_Struct(rb_ivar_get(item, id_buffer_data), struct buffer, buffer);
+            
+            buffer_update_cache(item);
+            buffer_write(item, commands);
             err = clSetKernelArg(kernel, i - 1, sizeof(cl_mem), &buffer->data);
-            if (buffer->num_items > global[0]) {
-                global[0] = buffer->num_items;
+            if (RARRAY_LEN(item) > global[0]) {
+                global[0] = RARRAY_LEN(item);
             }
         }
         else {
@@ -600,23 +592,28 @@ program_method_missing(int argc, VALUE *argv, VALUE self)
     
     clFinish(commands);
     
+    result = rb_ary_new();
+
     for (i = 1; i < argc; i++) {
         VALUE item = argv[i];
-        if (CLASS_OF(item) == rb_cOutputBuffer) {
-            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);
-            if (err != CL_SUCCESS) {
-                CLEAN();
-                rb_raise(rb_eOpenCLError, "failed to read output buffer");
+        if (CLASS_OF(item) == rb_cBuffer) {
+            if (RTEST(buffer_read(item, commands))) {
+                rb_ary_push(result, item);
             }
-            buffer_read(item);
         }
     }
 
     CLEAN();
-    return Qnil;
+    
+    if (RARRAY_LEN(result) == 0) {
+        return Qnil;
+    }
+    else if (RARRAY_LEN(result) == 1) {
+        return RARRAY_PTR(result)[0];
+    }
+    else {
+        return result;
+    }
 }
 
 static void
@@ -645,9 +642,10 @@ void
 Init_barracuda()
 {
     id_times = rb_intern("times");
+    id_new = rb_intern("new");
     id_to_sym = rb_intern("to_sym");
     id_data_type = rb_intern("data_type");
-    id_object = rb_intern("object");
+    id_buffer_data = rb_intern("buffer_data");
     
     rb_hTypes = rb_hash_new();
     rb_define_method(rb_mKernel, "Type", type_new, 1);
@@ -666,28 +664,19 @@ Init_barracuda()
     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_cBuffer = rb_define_class_under(rb_mBarracuda, "Buffer", rb_cArray);
     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=");
+    rb_define_method(rb_cBuffer, "outvar", buffer_outvar, 0);
+    rb_define_method(rb_cBuffer, "outvar?", buffer_is_outvar, 0);
+    rb_define_method(rb_cBuffer, "mark_dirty", buffer_mark_dirty, 0);
+    rb_define_method(rb_cBuffer, "dirty?", buffer_dirty, 0);
     
     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_cArray, "outvar", array_to_outvar, 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);