sgc-ruby-cuda 0.1.0

data/lib/cuda/runtime/version.rb

@@ -0,0 +1,51 @@
+#
+# 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 'cuda/runtime/ffi-cuda'
+
+
+module SGC
+module Cuda
+
+# @return [Integer] The CUDA driver version.
+def driver_version
+    p = FFI::MemoryPointer.new(:int)
+    status = API::cudaDriverGetVersion(p)
+    Pvt::handle_error(status, "Failed to query the CUDA driver version.")
+    p.read_int
+end
+module_function :driver_version
+
+
+# @return [Integer] The CUDA Runtime version.
+def runtime_version
+    p = FFI::MemoryPointer.new(:int)
+    status = API::cudaRuntimeGetVersion(p)
+    Pvt::handle_error(status, "Failed to query the CUDA Runtime version.")
+    p.read_int
+end
+module_function :runtime_version
+
+end # module
+end # module

data/lib/ffi/prettystruct.rb

@@ -0,0 +1,32 @@
+require 'ffi'
+
+
+module FFI
+
+# This class is obtained from ffi-tk (https://github.com/Tass/ffi-tk).
+class PrettyStruct < FFI::Struct
+    ACCESSOR_CODE = <<-CODE
+        def {name}; self[{sym}]; end
+        def {name}=(value) self[{sym}] = value; end
+    CODE
+
+    def self.layout(*kvs)
+        kvs.each_slice(2) do |key, value|
+            eval ACCESSOR_CODE.gsub(/\{(.*?)\}/, '{name}' => key, '{sym}' => ":#{key}")
+        end
+
+        super
+    end
+
+    def members
+        layout.members
+    end
+
+    def inspect
+        kvs = members.zip(values)
+        kvs.map!{|key, value| "%s=%s" % [key, value.inspect] }
+        "<%s %s>" % [self.class, kvs.join(' ')]
+    end
+end
+
+end # module

data/lib/helpers/flags.rb

@@ -0,0 +1,82 @@
+#
+# 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/>.
+#
+
+module SGC
+module Helper
+
+# Provide methods for evaluating the composite value of flags.
+# _self_ which _include/extend_ this module should implement {IEnum} interface.
+module FlagsValue
+
+    # @param [Symbol, Integer, Array<Symbol, Integer>] *flags The list of flags to include in the returning value.
+    # @raise [ArgumentError] Invalid symbol or value.
+    # @return [Integer] The composite value of the _flags_ with respect to _self_.
+    #
+    # @example Compute the composite value of flags with multiple symbols and integers.
+    #     CUEventFlags.symbols            #=> [:DEFAULT, :BLOCKING_SYNC, :DISABLE_TIMING]
+    #     CUEventFlags[:DEFAULT]          #=> 0
+    #     CUEventFlags[0]                 #=> :DEFAULT
+    #     CUEventFlags[:BLOCKING_SYNC]    #=> 1
+    #     CUEventFlags[1]                 #=> :BLOCKING_SYNC
+    #     CUEventFlags.value(:DISABLE_TIMING)                      #=> 2
+    #     CUEventFlags.value(:BLOCKING_SYNC, :DISABLE_TIMING)      #=> 3
+    #     CUEventFlags.value([:BLOCKING_SYNC, :DISABLE_TIMING])    #=> 3
+    #     CUEventFlags.value([1, :DISABLE_TIMING])                 #=> 3
+    def value(*flags)
+        flags.empty? == false or raise ArgumentError, "No flags is provided. Expect Array<Symbol, Integer>, Symbol or Integer."
+
+        f = 0
+        flags.flatten.each do |x|
+            case x
+                when Symbol
+                    v = self[x] or Pvt::raise_invalid_symbol(x)
+                    f |= v
+                when Integer
+                    self[x] or Pvt::raise_invalid_value(x)
+                    f |= x
+                else
+                    raise ArgumentError, "Invalid flags: #{x.to_s}. Expect Symbol or Integer in the flags array."
+            end
+        end
+        f
+    end
+
+
+    module Pvt
+
+        def raise_invalid_symbol(symbol)
+            raise ArgumentError, "Invalid flags symbol: #{symbol.to_s}. Expect symbol in #{self.symbols.to_s}."
+        end
+
+
+        def raise_invalid_value(value)
+            raise ArgumentError, "Invalid flags value: #{value.to_s}."
+        end
+
+    end
+
+end
+
+end # module
+end # module

data/lib/helpers/interface/ienum.rb

@@ -0,0 +1,45 @@
+#
+# 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/>.
+#
+
+module SGC
+module Helper
+
+# @abstract An Enum interface.
+# An enum maps a symbol to a value, and a value to a symbol.
+module IEnum
+
+    # @return [Array] The list of valid symbols of this enum.
+    def symbols; raise NotImplementedError; end
+
+    # @param [Symbol, Object] key A symbol or value to use as a key to map.
+    # @return [Symbol, Object] The symbol or value that the _key_ maps to.
+    #   * If the _key_ is a symbol, return the corresponding value.
+    #   * If the _key_ is a value, return the corresponding symbol.
+    #   * Return nil if the _key_ is invalid.
+    def [](key); raise NotImplementedError; end
+
+end
+
+end # module
+end # module

data/lib/helpers/klass.rb

@@ -0,0 +1,45 @@
+#
+# 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/>.
+#
+
+module SGC
+module Helper
+
+# @param [Class] klass The name of the class to obtain.
+# @return [String] The class name of the class without module string.
+#
+# @example Obtain the class name of the class.
+#     module A
+#         module B
+#             class C
+#             end
+#         end
+#     end
+#     classname(A::B::C)    #=> "C"
+def classname(klass)
+    klass.name.gsub(/.*\:\:/, "")
+end
+module_function :classname
+
+end # module
+end # module

data/lib/memory/buffer.rb

@@ -0,0 +1,125 @@
+#
+# 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'
+
+require 'memory/interface/ibuffer'
+require 'memory/pointer'
+
+
+module SGC
+module Memory
+
+# A memory buffer class which implements {IBuffer} interface.
+# @see IBuffer
+# @see IBuffer::ClassMethods
+class Buffer
+
+    include IBuffer
+
+
+    # @param [Symbol] type A symbol corresponds to a supported C data type, e.g. :int, :long, :float.
+    # @param [Integer] size The number of elements.
+    # @return A buffer with _size_ elements of _type_.
+    def initialize(type, size)
+        @@reads[type] && @@writes[type] or raise "Invalid buffer element type."
+
+        @reader = @@reads[type]
+        @writer = @@writes[type]
+        @ptr = FFI::MemoryPointer.new(type, size)
+        @size = size
+    end
+
+
+    # @param [Integer] index The index (0..size-1) of the element to return.
+    # @return The element at _index_ of this buffer.
+    def [](index)
+        assert_index(index)
+        @ptr[index].send(@reader)
+    end
+
+
+    # Set the element at _index_ of this buffer to _value_.
+    # @param [Integer] index The index (0..size-1) of the element to set.
+    # @param [Object] value The value to set to.
+    # @return _value_.
+    def []=(index, value)
+        assert_index(index)
+        @ptr[index].send(@writer, value)
+        value
+    end
+
+
+    # @return [Integer] The number of elements in this buffer.
+    def size
+        @size
+    end
+
+
+    # @return [Integer] The size of an element in this buffer in bytes.
+    def element_size
+        @ptr.type_size
+    end
+
+
+    # @private
+    def ptr
+        @ptr
+    end
+
+
+    # @private
+    def to_api
+        @ptr
+    end
+
+
+    # @param [Integer] index The index to an element in this buffer.
+    # @return [MemoryPointer] A memory pointer pointing to the _index_ element.
+    def offset(index)
+        assert_index(index)
+        MemoryPointer.new(@ptr[index])
+    end
+
+
+    # @param [Symbol] type A symbol corresponds to a supported C data type, e.g. :int, :long, :float.
+    # @return [Integer] The size of an element of _type_.
+    def self.element_size(type)
+        @@sizes[type]
+    end
+
+protected
+
+    def assert_index(i)
+        i >= 0 && i < @size or raise IndexError, "Invalid index to buffer: index = #{i}. Expect index in 0..#{@size-1}"
+    end
+
+    @@reads = { int: :read_int, long: :read_long, float: :read_float } # @private
+    @@writes = { int: :write_int, long: :write_long, float: :write_float } # @private
+    @@sizes = { int: 4, long: FFI::TypeDefs[:long].size, float: 4 } # @private
+
+end
+
+end # module
+end # module

data/lib/memory/interface/ibuffer.rb

@@ -0,0 +1,63 @@
+#
+# 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/>.
+#
+
+module SGC
+module Memory
+
+# @abstract A memory buffer interface.
+# A buffer stores elements of the same C data type.
+module IBuffer
+
+    # @param [Integer] index The index (0..size-1) of the element to return.
+    # @return The element at _index_ of this buffer.
+    def [](index); raise NotImplementedError; end
+
+    # Set the element at _index_ of this buffer to _value_.
+    # @param [Integer] index The index (0..size-1) of the element to set.
+    # @param [Object] value The value to set to.
+    # @return _value_.
+    def []=(index, value); raise NotImplementedError; end
+
+    # @return [Integer] The number of elements in this buffer.
+    def size; raise NotImplementedError; end
+
+    # @return [Integer] The size of an element in this buffer in bytes.
+    def element_size; raise NotImplementedError; end
+
+    # A set of methods automatically extended by the classes which _include_ _IBuffer_.
+    module ClassMethods
+        # @param [Symbol] type A symbol corresponds to a supported C data type, e.g. :int, :long, :float.
+        # @return [Integer] The size of an element of _type_.
+        def element_size(type); raise NotImplementedError; end
+    end
+
+    # @private
+    def self.included(base)
+        base.extend(ClassMethods)
+    end
+
+end
+
+end # module
+end # module