sgc-ruby-cuda 0.1.0

data/test/rubycu/test_cufunction.rb

@@ -0,0 +1,165 @@
+#-----------------------------------------------------------------------
+# 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 TestCUFunction < Test::Unit::TestCase
+
+    include CUTestBase
+
+
+    def test_function_set_param
+        da = CUDevice.malloc(1024)
+        db = CUDevice.malloc(1024)
+        dc = CUDevice.malloc(1024)
+        @func.param = []
+        @func.param = [da, db, dc, 10]
+
+        f = @func.param_setf(0, 2.5)
+        assert_instance_of(CUFunction, f)
+        f = @func.param_seti(4, 33)
+        assert_instance_of(CUFunction, f)
+        v = Buffer.new(:int, 1)
+        f = @func.param_setv(0, v, 4)
+        assert_instance_of(CUFunction, f)
+        f = @func.param_set_size(8)
+        assert_instance_of(CUFunction, f)
+
+        da.free
+        db.free
+        dc.free
+    end
+
+
+    def test_function_set_block_shape
+        @func.block_shape = 2
+        @func.block_shape = [2, 3]
+        @func.block_shape = 2, 3, 4
+    end
+
+
+    def test_function_set_shared_size
+        @func.shared_size = 0
+        @func.shared_size = 1024
+    end
+
+
+    def test_function_launch
+        assert_function_launch(10) do |f, params|
+            f.param = params
+            f.block_shape = 10
+            f.launch
+        end
+    end
+
+
+    def test_function_launch_grid
+        assert_function_launch(10) do |f, params|
+            f.param = params
+            f.block_shape = 10
+            f.launch_grid(1)
+        end
+
+        assert_function_launch(20) do |f, params|
+            f.param = params
+            f.block_shape = 5
+            f.launch_grid(4)
+        end
+    end
+
+
+    def test_function_launch_kernel
+        assert_function_launch(30) do |f, params|
+            f.launch_kernel(3, 1, 1, 10, 1, 1, 0, 0, params)
+        end
+    end
+
+
+    def test_function_launch_async
+        assert_nothing_raised do
+            assert_function_launch(10) do |f, params|
+                f.param = params
+                f.block_shape = 10
+                f.launch_grid_async(1, 0)
+            end
+
+            assert_function_launch(20) do |f, params|
+                f.param = params
+                f.block_shape = 5
+                f.launch_grid_async(4, 0)
+            end
+        end
+    end
+
+
+    def test_function_get_attribute
+        CUFunctionAttribute.symbols.each do |k|
+            v = @func.attribute(k)
+            assert_instance_of(Fixnum, v)
+        end
+    end
+
+
+    def test_function_set_cache_config
+        CUFunctionCache.symbols.each do |k|
+            @func.cache_config = k
+        end
+    end
+
+private
+
+    def assert_function_launch(size)
+        type = :int
+        element_size = 4
+        nbytes = size*element_size
+        da = CUDevice.malloc(nbytes)
+        db = CUDevice.malloc(nbytes)
+        dc = CUDevice.malloc(nbytes)
+        ha = Buffer.new(type, size)
+        hb = Buffer.new(type, size)
+        hc = Array.new(size)
+        hd = Buffer.new(type, size)
+        (0...size).each { |i|
+            ha[i] = i
+            hb[i] = 1
+            hc[i] = ha[i] + hb[i]
+            hd[i] = 0
+        }
+        CUMemory.memcpy_htod(da, ha, nbytes)
+        CUMemory.memcpy_htod(db, hb, nbytes)
+
+        yield @func, [da, db, dc, size]
+
+        CUMemory.memcpy_dtoh(hd, dc, nbytes)
+        (0...size).each { |i|
+            assert_equal(hc[i], hd[i])
+        }
+        da.free
+        db.free
+        dc.free
+    end
+
+end

data/test/rubycu/test_cumemory.rb

@@ -0,0 +1,113 @@
+#-----------------------------------------------------------------------
+# 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 TestCUMemory < Test::Unit::TestCase
+
+    include CUTestBase
+
+
+    def test_memory_copy
+        type = :int
+        size = 16
+        element_size = 4
+        nbytes = size*element_size
+        b = Buffer.new(type, size)
+        c = Buffer.new(type, size)
+        d = Buffer.new(type, size)
+        e = Buffer.new(type, size)
+        p = CUDevice.malloc(nbytes)
+        q = CUDevice.malloc(nbytes)
+        r = CUDevice.malloc(nbytes)
+
+        (0...size).each do |i|
+            b[i] = i
+            c[i] = 0
+            d[i] = 0
+            e[i] = 0
+        end
+
+        CUMemory.memcpy_htod(p, b, nbytes)
+        CUMemory.memcpy_dtoh(c, p, nbytes)
+        (0...size).each do |i|
+            assert_equal(b[i], c[i])
+        end
+
+        (0...size).each do |i|
+            b[i] = 2*i
+            c[i] = 0
+        end
+        CUMemory.memcpy_htod_async(p, b, nbytes, 0)
+        CUMemory.memcpy_dtoh_async(c, p, nbytes, 0)
+        CUContext.synchronize
+        (0...size).each do |i|
+            assert_equal(b[i], c[i])
+        end
+
+        CUMemory.memcpy_dtod(q, p, nbytes)
+        CUContext.synchronize
+        CUMemory.memcpy_dtoh(d, q, nbytes)
+        (0...size).each do |i|
+            assert_equal(b[i], d[i])
+        end
+
+        CUMemory.memcpy_dtod_async(r, p, size*element_size, 0)
+        CUContext.synchronize
+        CUMemory.memcpy_dtoh(e, r, nbytes)
+        (0...size).each do |i|
+            assert_equal(b[i], e[i])
+        end
+
+        if false    # FIXME: The memcpy is not working.
+        if @dev.attribute(:UNIFIED_ADDRESSING) > 0
+            (0...size).each do |i|
+                b[i] = i
+                c[i] = 0
+                d[i] = 0
+                e[i] = 0
+            end
+            CUMemory.memcpy(p, b, nbytes)
+            CUMemory.memcpy(c, p, nbytes)
+            (0...size).each do |i|
+                assert_equal(b[i], c[i])
+            end
+        end
+        end
+
+        p.free
+        q.free
+        r.free
+    end
+
+
+    def test_memory_get_info
+        info = CUMemory.mem_info
+        assert(info[:free] >= 0)
+        assert(info[:total] >= 0)
+    end
+
+end

data/test/rubycu/test_cumodule.rb

@@ -0,0 +1,114 @@
+#-----------------------------------------------------------------------
+# 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 TestCUModule < Test::Unit::TestCase
+
+    include CUTestBase
+
+
+    def test_module_load_unload
+        path = prepare_ptx
+        m = CUModule.new
+        m = m.load(path)
+        assert_instance_of(CUModule, m)
+        m = m.unload
+        assert_instance_of(CUModule, m)
+    end
+
+
+    def test_module_load_with_invalid_ptx
+        assert_raise(CUInvalidImageError) do
+            m = CUModule.new
+            m = m.load('test/bad.ptx')
+        end
+
+        assert_raise(CUFileNotFoundError) do
+            m = CUModule.new
+            m = m.load('test/notexists.ptx')
+        end
+    end
+
+
+    def test_module_load_data
+        path = prepare_ptx
+        m = CUModule.new
+        File.open(path) do |f|
+            str = f.read
+            r = m.load_data(str)
+            assert_instance_of(CUModule, r)
+            m.unload
+        end
+    end
+
+
+    def test_module_load_data_with_invalid_ptx
+        assert_raise(CUInvalidImageError) do
+            m = CUModule.new
+            str = "invalid ptx"
+            m.load_data(str)
+        end
+    end
+
+
+    def test_module_get_function
+        f = @mod.function('vadd')
+        assert_instance_of(CUFunction, f)
+    end
+
+
+    def test_module_get_function_with_invalid_name
+        assert_raise(CUInvalidValueError) do
+            f = @mod.function('')
+        end
+
+        assert_raise(CUReferenceNotFoundError) do
+            f = @mod.function('badname')
+        end
+    end
+
+
+    def test_module_get_global
+        devptr, nbytes = @mod.global('gvar')
+        assert_equal(4, nbytes)
+        u = Buffer.new(:int, 1)
+        CUMemory.memcpy_dtoh(u, devptr, nbytes)
+        assert_equal(1997, u[0])
+    end
+
+
+    def test_module_get_global_with_invalid_name
+        assert_raise(CUInvalidValueError) do
+            devptr, nbytes = @mod.global('')
+        end
+
+        assert_raise(CUReferenceNotFoundError) do
+            devptr, nbytes = @mod.global('badname')
+        end
+    end
+
+end

data/test/rubycu/test_custream.rb

@@ -0,0 +1,77 @@
+#-----------------------------------------------------------------------
+# 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 TestCUStream < Test::Unit::TestCase
+
+    include CUTestBase
+
+
+    def test_stream_create_destroy
+        s = CUStream.create
+        assert_instance_of(CUStream, s)
+        s = s.destroy
+        assert_nil(s)
+
+        s = CUStream.create(0)
+        assert_instance_of(CUStream, s)
+        s = s.destroy
+        assert_nil(s)
+    end
+
+
+    def test_stream_query
+        s = CUStream.create
+        b = s.query
+        assert(b)
+        s.destroy
+    end
+
+
+    def test_stream_synchronize
+        s = CUStream.create
+        s = s.synchronize
+        assert_instance_of(CUStream, s)
+        s.destroy
+    end
+
+
+    def test_stream_wait_event
+        s = CUStream.create
+        e = CUEvent.create
+        s = s.wait_event(e)
+        assert_instance_of(CUStream, s)
+        s = s.wait_event(e, 0)
+        assert_instance_of(CUStream, s)
+        s.destroy
+        s = CUStream.wait_event(e)
+        assert_nil(s)
+        s = CUStream.wait_event(e, 0)
+        assert_nil(s)
+    end
+
+end