sgc-ruby-cuda 0.1.0

data/lib/memory/pointer.rb

@@ -0,0 +1,72 @@
+#
+# Copyright (c) 2010-2011 Chung Shin Yee
+#
+#       shinyee@speedgocomputing.com
+#       http://www.speedgocomputing.com
+#       http://github.com/xman/sgc-ruby-cuda
+#       http://rubyforge.org/projects/rubycuda
+#
+# This file is part of SGC-Ruby-CUDA.
+#
+# SGC-Ruby-CUDA is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SGC-Ruby-CUDA is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SGC-Ruby-CUDA.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+require 'ffi'
+
+
+module SGC
+module Memory
+
+# A memory pointer class.
+class MemoryPointer
+
+    # @param [Integer] addr Memory address _addr_ to initialize to.
+    # @return A memory pointer pointing to address _addr_.
+    def initialize(addr = nil)
+        @p = FFI::MemoryPointer.new(:pointer)
+        @p.write_long(addr.to_i)
+    end
+
+
+    # @return The internal pointer representation.
+    def ptr
+        @p.read_pointer
+    end
+
+
+    # Set this pointer to point to memory address _addr_.
+    # @param [Integer] addr Memory address to set to.
+    # @return _addr_.
+    def ptr=(addr)
+        @p.write_pointer(addr)
+        addr
+    end
+
+
+    # @param [Integer] index Index to a memory offset.
+    # @return [MemoryPointer] A memory pointer pointing to the _index_ byte.
+    def offset(index)
+        MemoryPointer.new(@p.read_pointer.to_i + index)
+    end
+
+
+    # @return The internal representation of a pointer pointing to this memory pointer.
+    def ref
+        @p
+    end
+
+end
+
+end # module
+end # module

data/lib/rubycu.rb

@@ -0,0 +1 @@
+require 'cuda/driver/rubycu'

data/lib/rubycuda.rb

@@ -0,0 +1 @@
+require 'cuda/runtime/rubycuda'

data/test/memory/test_buffer.rb

@@ -0,0 +1,93 @@
+#-----------------------------------------------------------------------
+# Copyright (c) 2010-2011 Chung Shin Yee
+#
+#       shinyee@speedgocomputing.com
+#       http://www.speedgocomputing.com
+#       http://github.com/xman/sgc-ruby-cuda
+#       http://rubyforge.org/projects/rubycuda
+#
+# This file is part of SGC-Ruby-CUDA.
+#
+# SGC-Ruby-CUDA is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SGC-Ruby-CUDA is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SGC-Ruby-CUDA.  If not, see <http://www.gnu.org/licenses/>.
+#-----------------------------------------------------------------------
+
+require 'test/unit'
+require 'memory/buffer'
+
+include SGC::Memory
+
+
+class TestMemoryBuffer < Test::Unit::TestCase
+
+    def test_buffer_initialize
+        b = Buffer.new(:int, 10)
+        assert_instance_of(Buffer, b)
+        assert_equal(10, b.size)
+
+        b = Buffer.new(:long, 20)
+        assert_instance_of(Buffer, b)
+        assert_equal(20, b.size)
+
+        b = Buffer.new(:float, 30)
+        assert_instance_of(Buffer, b)
+        assert_equal(30, b.size)
+    end
+
+
+    def test_buffer_element_size
+        assert_equal(4, Buffer.element_size(:int))
+        assert_equal(4, Buffer.element_size(:float))
+    end
+
+
+    def test_buffer_offset
+        b = Buffer.new(:int, 16)
+        c = b.offset(4)
+        assert_kind_of(MemoryPointer, c)
+
+        b = Buffer.new(:int, 10)
+        c = b.offset(5)
+        assert_kind_of(MemoryPointer, c)
+
+        b = Buffer.new(:long, 10)
+        c = b.offset(3)
+        assert_kind_of(MemoryPointer, c)
+
+        b = Buffer.new(:float, 10)
+        c = b.offset(4)
+        assert_kind_of(MemoryPointer, c)
+    end
+
+
+    def test_buffer_access
+        b = Buffer.new(:int, 10)
+        b[0] = 10
+        assert_equal(10, b[0])
+        b[9] = 20
+        assert_equal(20, b[9])
+
+        b = Buffer.new(:long, 10)
+        b[3] = 2**40
+        assert_equal(2**40, b[3])
+        b[7] = 2**50
+        assert_equal(2**50, b[7])
+
+        b = Buffer.new(:float, 10)
+        b[2] = 3.14
+        assert_in_delta(3.14, b[2])
+        b[8] = 9.33
+        assert_in_delta(9.33, b[8])
+    end
+
+end

data/test/rubycu/test_cucontext.rb

@@ -0,0 +1,148 @@
+#-----------------------------------------------------------------------
+# Copyright (c) 2010-2011 Chung Shin Yee
+#
+#       shinyee@speedgocomputing.com
+#       http://www.speedgocomputing.com
+#       http://github.com/xman/sgc-ruby-cuda
+#       http://rubyforge.org/projects/rubycuda
+#
+# This file is part of SGC-Ruby-CUDA.
+#
+# SGC-Ruby-CUDA is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SGC-Ruby-CUDA is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SGC-Ruby-CUDA.  If not, see <http://www.gnu.org/licenses/>.
+#-----------------------------------------------------------------------
+
+require 'test/unit'
+require_relative 'testbase'
+
+
+class TestCUContext < Test::Unit::TestCase
+
+    include CUTestBase
+
+
+    def test_context_create_destroy
+        c = CUContext.create(@dev)
+        assert_instance_of(CUContext, c)
+        c = c.destroy
+        assert_nil(c)
+        c = CUContext.create(0, @dev)
+        assert_instance_of(CUContext, c)
+        c = c.destroy
+        assert_nil(c)
+        CUContextFlags.symbols.each do |k|
+            c = CUContext.create(k, @dev)
+            assert_instance_of(CUContext, c)
+            c = c.destroy
+            assert_nil(c)
+        end
+    end
+
+
+    def test_context_current
+        c = CUContext.current
+        assert_instance_of(CUContext, c)
+        CUContext.current = c
+    end
+
+
+    def test_context_attach_detach
+        c1 = @ctx.attach(0)
+        assert_instance_of(CUContext, c1)
+        c2 = @ctx.detach
+        assert_nil(c2)
+    end
+
+
+    def test_context_attach_nonzero_flags_detach
+        assert_raise(CUInvalidValueError) do
+            c1 = @ctx.attach(999)
+            assert_instance_of(CUContext, c1)
+            c2 = @ctx.detach
+            assert_nil(c2)
+        end
+    end
+
+
+    def test_context_push_pop_current
+        c1 = CUContext.pop_current
+        assert_instance_of(CUContext, c1)
+        c2 = @ctx.push_current
+        assert_instance_of(CUContext, c2)
+    end
+
+
+    def test_context_get_device
+        d = CUContext.device
+        assert_device(d)
+    end
+
+
+    def test_context_get_set_limit
+        if @dev.compute_capability[:major] >= 2
+            assert_limit = Proc.new { |&b| assert_nothing_raised(&b) }
+        else
+            assert_limit = Proc.new { |&b| assert_raise(CUUnsupportedLimitError, &b) }
+        end
+        assert_limit.call do
+            stack_size = CUContext.limit(:STACK_SIZE)
+            assert_kind_of(Integer, stack_size)
+            fifo_size = CUContext.limit(:PRINTF_FIFO_SIZE)
+            assert_kind_of(Integer, fifo_size)
+            heap_size = CUContext.limit(:MALLOC_HEAP_SIZE)
+            assert_kind_of(Integer, heap_size)
+            CUContext.limit = [:STACK_SIZE, stack_size]
+            s = CUContext.limit(:STACK_SIZE)
+            assert_equal(stack_size, s)
+            CUContext.limit = [:PRINTF_FIFO_SIZE, fifo_size]
+            s = CUContext.limit(:PRINTF_FIFO_SIZE)
+            assert_equal(fifo_size, s)
+            CUContext.limit = :MALLOC_HEAP_SIZE, heap_size
+            s = CUContext.limit(:MALLOC_HEAP_SIZE)
+            assert_equal(heap_size, s)
+        end
+    end
+
+
+    def test_context_get_set_cache_config
+        if @dev.compute_capability[:major] >= 2
+            config = CUContext.cache_config
+            assert_not_nil(CUFunctionCache[config])
+            CUContext.cache_config = config
+            c = CUContext.cache_config
+            assert_equal(config, c)
+        else
+            config = CUContext.cache_config
+            assert_equal(:PREFER_NONE, config)
+            CUContext.cache_config = config
+            c = CUContext.cache_config
+            assert_equal(:PREFER_NONE, c)
+        end
+    end
+
+
+    def test_context_get_api_version
+        v1 = @ctx.api_version
+        v2 = CUContext.api_version
+        assert_kind_of(Integer, v1)
+        assert_kind_of(Integer, v2)
+        assert(v1 == v2)
+    end
+
+
+    def test_context_synchronize
+        s = CUContext.synchronize
+        assert_nil(s)
+    end
+
+end

data/test/rubycu/test_cudevice.rb

@@ -0,0 +1,69 @@
+#-----------------------------------------------------------------------
+# Copyright (c) 2010-2011 Chung Shin Yee
+#
+#       shinyee@speedgocomputing.com
+#       http://www.speedgocomputing.com
+#       http://github.com/xman/sgc-ruby-cuda
+#       http://rubyforge.org/projects/rubycuda
+#
+# This file is part of SGC-Ruby-CUDA.
+#
+# SGC-Ruby-CUDA is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SGC-Ruby-CUDA is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SGC-Ruby-CUDA.  If not, see <http://www.gnu.org/licenses/>.
+#-----------------------------------------------------------------------
+
+require 'test/unit'
+require_relative 'testbase'
+
+
+class TestCUDevice < Test::Unit::TestCase
+
+    include CUTestBase
+
+
+    def test_device_count
+        count = CUDevice.count
+        assert(count > 0, "Device count failed.")
+    end
+
+
+    def test_device_query
+        d = @dev
+        assert_instance_of(CUDevice, d)
+        assert_device_name(d)
+        assert_device_memory_size(d)
+        assert_device_capability(d)
+        assert_device_properties(d)
+        CUDeviceAttribute.symbols.each do |k|
+            v = d.attribute(k)
+            assert_instance_of(Fixnum, v)
+        end
+    end
+
+
+    def test_device_malloc_free
+        p = CUDevice.malloc(1024)
+        assert_instance_of(CUDevicePtr, p)
+        r = p.free
+        assert_nil(r)
+    end
+
+
+    def test_device_malloc_with_huge_mem
+        assert_raise(CUOutOfMemoryError) do
+            size = @dev.total_mem + 1
+            CUDevice.malloc(size)
+        end
+    end
+
+end

data/test/rubycu/test_cudeviceptr.rb

@@ -0,0 +1,43 @@
+#-----------------------------------------------------------------------
+# Copyright (c) 2010-2011 Chung Shin Yee
+#
+#       shinyee@speedgocomputing.com
+#       http://www.speedgocomputing.com
+#       http://github.com/xman/sgc-ruby-cuda
+#       http://rubyforge.org/projects/rubycuda
+#
+# This file is part of SGC-Ruby-CUDA.
+#
+# SGC-Ruby-CUDA is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SGC-Ruby-CUDA is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SGC-Ruby-CUDA.  If not, see <http://www.gnu.org/licenses/>.
+#-----------------------------------------------------------------------
+
+require 'test/unit'
+require_relative 'testbase'
+
+
+class TestCUDevicePtr < Test::Unit::TestCase
+
+    include CUTestBase
+
+
+    def test_device_ptr_offset
+        devptr = CUDevice.malloc(1024)
+        p = devptr.offset(1024)
+        assert_instance_of(CUDevicePtr, p)
+        p = devptr.offset(-1024)
+        assert_instance_of(CUDevicePtr, p)
+        devptr.free
+    end
+
+end

data/test/rubycu/test_cuevent.rb

@@ -0,0 +1,81 @@
+#-----------------------------------------------------------------------
+# Copyright (c) 2010-2011 Chung Shin Yee
+#
+#       shinyee@speedgocomputing.com
+#       http://www.speedgocomputing.com
+#       http://github.com/xman/sgc-ruby-cuda
+#       http://rubyforge.org/projects/rubycuda
+#
+# This file is part of SGC-Ruby-CUDA.
+#
+# SGC-Ruby-CUDA is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# SGC-Ruby-CUDA is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with SGC-Ruby-CUDA.  If not, see <http://www.gnu.org/licenses/>.
+#-----------------------------------------------------------------------
+
+require 'test/unit'
+require_relative 'testbase'
+
+
+class TestCUEvent < Test::Unit::TestCase
+
+    include CUTestBase
+
+
+    def test_event_create_destroy
+        e = CUEvent.create
+        assert_instance_of(CUEvent, e)
+        e = e.destroy
+        assert_nil(e)
+
+        e = CUEvent.create(:DEFAULT)
+        assert_instance_of(CUEvent, e)
+        e = e.destroy
+        assert_nil(e)
+
+        e = CUEvent.create(:DEFAULT, :BLOCKING_SYNC)
+        assert_instance_of(CUEvent, e)
+        e = e.destroy
+        assert_nil(e)
+
+        e = CUEvent.create([:BLOCKING_SYNC, :DISABLE_TIMING])
+        assert_instance_of(CUEvent, e)
+        e = e.destroy
+        assert_nil(e)
+    end
+
+
+    def test_event_record_synchronize_query
+        e = CUEvent.create(:DEFAULT)
+        e = e.record(0)
+        assert_instance_of(CUEvent, e)
+        e = e.synchronize
+        assert_instance_of(CUEvent, e)
+        b = e.query
+        assert(b)
+        e.destroy
+    end
+
+
+    def test_event_elapsed_time
+        e1 = CUEvent.create(:DEFAULT)
+        e2 = CUEvent.create(:DEFAULT)
+        e1.record(0)
+        e2.record(0)
+        e2.synchronize
+        elapsed = CUEvent.elapsed_time(e1, e2)
+        assert_instance_of(Float, elapsed)
+        e1.destroy
+        e2.destroy
+    end
+
+end