barracuda 1.2 → 1.3

data/test/test_buffer.rb

@@ -0,0 +1,38 @@
+$:.unshift(File.dirname(__FILE__) + '/../ext/')
+
+require "test/unit"
+require "barracuda"
+
+include Barracuda
+
+class TestBuffer < Test::Unit::TestCase
+  def test_buffer_create_invalid_data
+    assert_raise(TypeError) { 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
+  end
+  
+  def test_buffer_create_with_size
+    b = Buffer.new(80)
+    assert_equal 80, b.size
+  end
+  
+  def test_buffer_mark_dirty
+    b = Buffer.new([4, 2, 3])
+    b.mark_dirty
+    assert b.dirty?
+  end
+  
+  def test_buffer_from_array
+    b = Array.new(80).outvar
+    assert_kind_of Buffer, b
+  end
+  
+  def test_outvar_buffer
+    b = Buffer.new(8)
+    assert b.outvar?
+  end
+end

data/test/test_program.rb

@@ -0,0 +1,206 @@
+$:.unshift(File.dirname(__FILE__) + '/../ext/')
+
+require "test/unit"
+require "barracuda"
+
+include Barracuda
+
+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_raise(ArgumentError) { 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_implicit_array_buffer
+    p = Program.new <<-'eof'
+      __kernel copy(__global int *out, __global int *in) {
+        int i = get_global_id(0);
+        out[i] = in[i] + 1;
+      }
+    eof
+    
+    out = Buffer.new(3)
+    p.copy(out, [1, 2, 3])
+    assert_equal [2, 3, 4], out
+  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
+  
+      p.compile <<-eof
+        __kernel run(__global #{type} *out, __global #{type} *in) {
+          int id = get_global_id(0);
+          out[id] = in[id] + 1;
+        }
+      eof
+    
+      out = Buffer.new(arr.size).to_type(type)
+      p.run(out, arr.to_type(type))
+      assert_equal({type => outarr}, {type => out})
+    end
+  end
+  
+  def test_program_int_input_buffer
+    p = Program.new <<-'eof'
+      __kernel run(__global int* out, __global int* in) {
+        int id = get_global_id(0);
+        out[id] = in[id] + 1; 
+      }
+    eof
+    
+    input = (1..256).to_a
+    out = Buffer.new(input.size).to_type(:int)
+    p.run(out, input)
+    assert_equal input.map {|x| x + 1 }, out
+  end
+  
+  def test_program_float_buffer
+    p = Program.new <<-'eof'
+      __kernel run(__global float* out, __global int* in) {
+        int id = get_global_id(0);
+        out[id] = (float)in[id] + 0.5; 
+      }
+    eof
+    
+    input = (1..256).to_a
+    out = Buffer.new(input.size).to_type(:float)
+    p.run(out, input)
+    assert_equal input.map {|x| x.to_f + 0.5 }, out
+  end
+  
+  def test_program_set_times
+    p = Program.new <<-'eof'
+      __kernel sum(__global int* out, __global int* in) {
+        int id = get_global_id(0);
+        atom_add(out, in[id]); 
+      }
+    eof
+    
+    input = (1..517).to_a
+    sum = input.inject(0) {|acc, el| acc + el }
+    out = Buffer.new(1)
+    p.sum(out, input, :times => input.size)
+    assert_equal sum, out[0]
+  end
+  
+  def test_program_largest_buffer_is_input
+    p = Program.new <<-'eof'
+      __kernel sum(__global int* out, __global int* in) {
+        int id = get_global_id(0);
+        atom_add(out, in[id]); 
+      }
+    eof
+    
+    input = (1..517).to_a
+    sum = input.inject(0) {|acc, el| acc + el }
+    out = Buffer.new(1)
+    p.sum(out, input)
+    assert_equal sum, out[0]
+  end
+  
+  def test_program_invalid_times
+    p = Program.new("__kernel sum(int x) { }")
+    assert_raise(ArgumentError) { p.sum(:times => "hello") }
+    assert_raise(ArgumentError) { p.sum(:time => 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, Buffer.new(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 = Buffer.new(4).to_type(:float)
+    p.copy_to_out(out, [2.5, 2.5, 2.5, 2.5])
+    assert_equal [3, 3, 3, 3], out
+  end
+  
+  def test_program_no_total
+    p = Program.new <<-'eof'
+      __kernel copy(__global int *out, __global int *in) {
+        int i = get_global_id(0);
+        out[i] = in[i] + 1;
+      }
+    eof
+    
+    out = Buffer.new(3)
+    p.copy(out, (1..3).to_a)
+    assert_equal (2..4).to_a, out
+  
+    out = Buffer.new(50446)
+    p.copy(out, (1..50446).to_a)
+    assert_equal (2..50447).to_a, out
+  end
+  
+  def test_program_returns_outvars_as_array
+    p = Program.new <<-'eof'
+      __kernel outbufs(__global int *a, __global int *b, int x, __global int *c) {
+        int i = get_global_id(0);
+        a[i] = x+1; b[i] = x+2; c[i] = x+3;
+      }
+    eof
+    
+    a, b, c = Buffer.new(10), Buffer.new(10), Buffer.new(10)
+    result = p.outbufs(a, b, 5, c)
+    assert_equal [a, b, c], result
+  end
+  
+  def test_program_returns_buffer_for_single_outvar
+    p = Program.new <<-'eof'
+      __kernel outbufs(__global int *a, __global int *b) {
+        int i = get_global_id(0);
+        a[i] = b[i];
+      }
+    eof
+    
+    a, b = Buffer.new(5), (1..5).to_a
+    result = p.outbufs(a, b)
+    assert_equal a, result
+  end
+  
+  def test_program_outvar
+    p = Program.new <<-'eof'
+      __kernel add5(__global int *data) {
+        int i = get_global_id(0);
+        data[i] = data[i] + 5;
+      }
+    eof
+    
+    data = [1, 2, 3].outvar
+    assert_equal [6, 7, 8], p.add5(data)
+  end
+end

data/test/test_types.rb

@@ -0,0 +1,68 @@
+$:.unshift(File.dirname(__FILE__) + '/../ext/')
+
+require "test/unit"
+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_array_type
+    assert_equal :uchar, [2].to_type(:uchar).data_type
+  end
+  
+  def test_set_buffer_type
+    assert_equal :uchar, Buffer.new([2]).to_type(:uchar).data_type
+  end
+  
+  def test_conversion_to_buffer_maintains_data_type
+    o = [2].to_type(:uchar)
+    assert_equal :uchar, Buffer.new(o).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(TypeError) { [Object.new].data_type }
+    assert_raise(TypeError) { ['x'].data_type }
+    assert_raise(TypeError) { [].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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: barracuda
 version: !ruby/object:Gem::Version 
-  version: "1.2"
+  version: "1.3"
 platform: ruby
 authors: 
 - Loren Segal
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-03 00:00:00 -04:00
+date: 2009-09-06 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -25,9 +25,10 @@ files:
 - ext/barracuda.c
 - ext/extconf.rb
 - benchmarks/normalize.rb
-- benchmarks/sort.rb
 - benchmarks/to_float.rb
-- test/test_barracuda.rb
+- test/test_buffer.rb
+- test/test_program.rb
+- test/test_types.rb
 - LICENSE
 - README.md
 - Rakefile
@@ -60,4 +61,6 @@ signing_key:
 specification_version: 3
 summary: Barracuda is a wrapper library for OpenCL/CUDA GPGPU programming
 test_files: 
-- test/test_barracuda.rb
+- test/test_buffer.rb
+- test/test_program.rb
+- test/test_types.rb

data/benchmarks/sort.rb

@@ -1,29 +0,0 @@
-$:.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);
-    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 = 10000
-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/test/test_barracuda.rb

@@ -1,291 +0,0 @@
-$:.unshift(File.dirname(__FILE__) + '/../ext/')
-
-require "test/unit"
-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 }
-  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_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) }
-  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_raise(ArgumentError) { 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_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) {
-        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_times
-    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, 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, :times => 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, 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_times
-    p = Program.new("__kernel sum(int x) { }")
-    assert_raise(ArgumentError) { p.sum(:times => "hello") }
-    assert_raise(ArgumentError) { p.sum(:time => 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
-  
-  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
-  
-  def test_program_no_total
-    p = Program.new <<-'eof'
-      __kernel copy(__global int *out, __global int *in) {
-        int i = get_global_id(0);
-        out[i] = in[i] + 1;
-      }
-    eof
-    
-    out = OutputBuffer.new(:int, 3)
-    p.copy(out, (1..3).to_a)
-    assert_equal (2..4).to_a, out.data
-
-    out = OutputBuffer.new(:int, 50446)
-    p.copy(out, (1..50446).to_a)
-    assert_equal (2..50447).to_a, out.data
-  end
-end