sgc-ruby-cuda 0.1.0

data/test/rubycu/test_cuversion.rb

@@ -0,0 +1,39 @@
+#-----------------------------------------------------------------------
+# 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 TestCUVersion < Test::Unit::TestCase
+
+    include CUTestBase
+
+
+    def test_version
+        v = driver_version
+        assert_kind_of(Integer, v)
+    end
+
+end

data/test/rubycu/testbase.rb

@@ -0,0 +1,107 @@
+#-----------------------------------------------------------------------
+# 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 'rubycu'
+
+include SGC::CU
+include SGC::CU::Error
+
+CUInit.init
+
+
+module CUTestBase
+
+    def setup
+        @dev = CUDevice.get(ENV['DEVID'].to_i)
+        @ctx = CUContext.create(@dev)
+        @mod = prepare_loaded_module
+        @func = @mod.function("vadd")
+    end
+
+    def teardown
+        @func = nil
+        @mod.unload
+        @mod = nil
+        @ctx.destroy
+        @ctx = nil
+        @dev = nil
+    end
+
+
+    def prepare_ptx
+        if File.exists?('test/vadd.ptx') == false || File.mtime('test/vadd.cu') > File.mtime('test/vadd.ptx')
+            system %{cd test; nvcc --ptx vadd.cu}
+        end
+        'test/vadd.ptx'
+    end
+
+
+    def prepare_loaded_module
+        path = prepare_ptx
+        m = CUModule.new
+        m.load(path)
+    end
+
+
+    def assert_device(dev)
+        assert_device_name(dev)
+        assert_device_memory_size(dev)
+        assert_device_capability(dev)
+        assert_device_properties(dev)
+    end
+
+    def assert_device_name(dev)
+        assert(dev.name.size > 0, "Device name failed.")
+    end
+
+    def assert_device_memory_size(dev)
+        assert(dev.total_mem > 0, "Device total memory size failed.")
+    end
+
+    def assert_device_capability(dev)
+        cap = dev.compute_capability
+        assert(cap[:major] > 0 && cap[:minor] >= 0, "Device compute capability failed.")
+    end
+
+    def assert_device_properties(dev)
+        p = dev.properties
+        assert(p[:clock_rate] > 0)
+        assert(p[:max_threads_per_block] > 0)
+        assert(p[:mem_pitch] > 0)
+        assert(p[:regs_per_block] > 0)
+        assert(p[:shared_mem_per_block] > 0)
+        assert(p[:simd_width] > 0)
+        assert(p[:texture_align] > 0)
+        assert(p[:total_constant_memory] > 0)
+        assert_equal(3, p[:max_grid_size].count)
+        assert_kind_of(Integer, p[:max_grid_size][0])
+        assert_kind_of(Integer, p[:max_grid_size][1])
+        assert_kind_of(Integer, p[:max_grid_size][2])
+        assert_equal(3, p[:max_threads_dim].count)
+        assert_kind_of(Integer, p[:max_threads_dim][0])
+        assert_kind_of(Integer, p[:max_threads_dim][1])
+        assert_kind_of(Integer, p[:max_threads_dim][2])
+    end
+
+end

data/test/rubycuda/test_cudadevice.rb

@@ -0,0 +1,125 @@
+#-----------------------------------------------------------------------
+# Copyright (c) 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 TestCudaDevice < Test::Unit::TestCase
+
+    include CudaTestBase
+
+
+    def test_device_count
+        count = CudaDevice.count
+        assert(count > 0, "Device count failed.")
+    end
+
+
+    def test_device_get_set
+        count = CudaDevice.count
+        (0...count).each do |devid|
+            r = CudaDevice.set(devid)
+            assert_equal(CudaDevice, r)
+            d = CudaDevice.get
+            assert_equal(devid, d)
+        end
+
+        count = CudaDevice.count
+        (0...count).each do |devid|
+            CudaDevice.current = devid
+            d = CudaDevice.current
+            assert_equal(devid, d)
+        end
+    end
+
+
+    def test_device_choose
+        count = CudaDevice.count
+        prop = CudaDeviceProp.new
+        devid = CudaDevice.choose(prop)
+        assert(devid >= 0 && devid < count)
+    end
+
+
+    def test_device_properties
+        prop = CudaDevice.properties
+        assert_instance_of(CudaDeviceProp, prop)
+        # TODO: assert the content of the _prop_.
+    end
+
+
+    def test_device_flags
+        CudaDeviceFlags.symbols.each do |k|
+            CudaDevice.flags = k
+        end
+    end
+
+
+    def test_device_valid_devices
+        count = CudaDevice.count
+        devs = []
+        (0...count).each do |devid|
+            devs << devid
+        end
+        CudaDevice.valid_devices = devs
+    end
+
+
+    def test_device_cache_config
+        if CudaDevice.properties.major >= 2
+            CudaFunctionCache.symbols.each do |k|
+                CudaDevice.cache_config = k
+                c = CudaDevice.cache_config
+                assert_equal(k, c)
+            end
+        end
+    end
+
+
+    def test_device_limit
+        CudaLimit.symbols.each do |k|
+            begin
+                u = CudaDevice.limit(k)
+                CudaDevice.limit = [k, u]
+                v = CudaDevice.limit(k)
+                assert_equal(u, v)
+            rescue CudaUnsupportedLimitError
+            end
+        end
+    end
+
+
+    def test_device_reset
+        r = CudaDevice.reset
+        assert_equal(CudaDevice, r)
+    end
+
+
+    def test_device_synchronize
+        r = CudaDevice.synchronize
+        assert_equal(CudaDevice, r)
+    end
+
+end

data/test/rubycuda/test_cudaerror.rb

@@ -0,0 +1,48 @@
+#-----------------------------------------------------------------------
+# Copyright (c) 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 TestCudaError < Test::Unit::TestCase
+
+    include CudaTestBase
+
+
+    def test_error
+        CudaError.symbols.each do |k|
+            s = get_error_string(k)
+            assert(s.size > 0)
+        end
+        e = get_last_error
+        s = get_error_string(e)
+        assert(s.size > 0)
+
+        e = peek_at_last_error
+        s = get_error_string(e)
+        assert(s.size > 0)
+    end
+
+end

data/test/rubycuda/test_cudaevent.rb

@@ -0,0 +1,78 @@
+#-----------------------------------------------------------------------
+# Copyright (c) 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 TestCudaEvent < Test::Unit::TestCase
+
+    include CudaTestBase
+
+
+    def test_event_create_destroy
+        e = CudaEvent.create
+        assert_instance_of(CudaEvent, e)
+        r = e.destroy
+        assert_nil(r)
+
+        e = CudaEvent.create(CudaEventFlags.value(:DEFAULT, :BLOCKING_SYNC))
+        assert_instance_of(CudaEvent, e)
+        r = e.destroy
+        assert_nil(r)
+
+        e = CudaEvent.create(:DEFAULT, :BLOCKING_SYNC)
+        assert_instance_of(CudaEvent, e)
+        r = e.destroy
+        assert_nil(r)
+    end
+
+
+    def test_event_record_synchronize_query
+        e = CudaEvent.create
+        e = e.record
+        assert_instance_of(CudaEvent, e)
+        e = e.synchronize
+        assert_instance_of(CudaEvent, e)
+        b = e.query
+        assert(b)
+        e.destroy
+    end
+
+
+    def test_event_elapsed_time
+        e1 = CudaEvent.create
+        e2 = CudaEvent.create
+
+        e1.record
+        e2.record
+        e2.synchronize
+        t = CudaEvent.elapsed_time(e1, e2)
+        assert_kind_of(Numeric, t)
+
+        e1.destroy
+        e2.destroy
+    end
+
+end

data/test/rubycuda/test_cudafunction.rb

@@ -0,0 +1,106 @@
+#-----------------------------------------------------------------------
+# Copyright (c) 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 TestCudaFunction < Test::Unit::TestCase
+
+    include CudaTestBase
+
+
+    def test_function_name
+        f = CudaFunction.new("vadd")
+        assert_equal("vadd", f.name)
+    end
+
+
+    def test_function_attributes
+        path = prepare_kernel_lib
+        CudaFunction.load_lib_file(path)
+        f = CudaFunction.new("vadd")
+        a = f.attributes
+        assert_instance_of(CudaFunctionAttributes, a)
+        CudaFunction.unload_all_libs
+    end
+
+
+    def test_function_cache_config
+        path = prepare_kernel_lib
+        CudaFunction.load_lib_file(path)
+        f = CudaFunction.new("vadd")
+        CudaFunctionCache.symbols.each do |k|
+            f.cache_config = k
+        end
+        CudaFunction.unload_all_libs
+    end
+
+
+    def test_function_launch
+        type = :int
+        size = 10
+        nbytes = size*4
+
+        a = Buffer.new(type, size)
+        b = Buffer.new(type, size)
+        c = Buffer.new(type, size)
+
+        p = CudaDeviceMemory.malloc(nbytes)
+        q = CudaDeviceMemory.malloc(nbytes)
+        r = CudaDeviceMemory.malloc(nbytes)
+
+        (0...size).each do |i|
+            a[i] = i
+            b[i] = 2
+            c[i] = 0
+        end
+
+        CudaMemory.memcpy_htod(p, a, nbytes)
+        CudaMemory.memcpy_htod(q, b, nbytes)
+        CudaMemory.memcpy_htod(r, c, nbytes)
+
+        path = prepare_kernel_lib
+        CudaFunction.load_lib_file(path)
+
+        CudaFunction.configure(Dim3.new(1, 1, 1), Dim3.new(size, 1, 1))
+        CudaFunction.setup(p, q, r, size)
+
+        f = CudaFunction.new("vadd")
+        f.launch
+
+        CudaMemory.memcpy_dtoh(c, r, nbytes)
+
+        (0...size).each do |i|
+            assert_equal(a[i] + b[i], c[i])
+        end
+
+        CudaFunction.unload_all_libs
+
+        CudaDeviceMemory.free(p)
+        CudaDeviceMemory.free(q)
+        CudaDeviceMemory.free(r)
+    end
+
+end