sgc-ruby-cuda 0.1.0

data/lib/cuda/driver/module.rb

@@ -0,0 +1,142 @@
+#
+# 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 'cuda/driver/ffi-cu'
+require 'cuda/driver/cu'
+require 'cuda/driver/error'
+require 'cuda/driver/function'
+
+
+module SGC
+module CU
+
+class CUModule
+
+    # Allocate a CUDA module.
+    def initialize
+        @pmod = FFI::MemoryPointer.new(:CUModule)
+    end
+
+
+    # Load a compute module from the file at _path_ into the current CUDA context.
+    # The file should be a cubin file or a PTX file.
+    #
+    # A PTX file may be obtained by compiling the .cu file using nvcc with -ptx option.
+    #    $ nvcc -ptx vadd.cu
+    #
+    # @param [String] path The path of the file to load.
+    # @return [CUModule] This CUDA module.
+    def load(path)
+        status = API::cuModuleLoad(@pmod, path)
+        Pvt::handle_error(status, "Failed to load module: path = #{path}.")
+        self
+    end
+
+
+    # Load a compute module from the String _image_str_ into the current CUDA context.
+    # @param [String] image_str A string which contains a cubin or a PTX data.
+    # @return [CUModule] This CUDA module.
+    #
+    # @see #load
+    def load_data(image_str)
+        status = API::cuModuleLoadData(@pmod, image_str)
+        Pvt::handle_error(status, "Failed to load module data.")
+        self
+    end
+
+
+    # @note Not implemented yet.
+    #
+    # @see #load
+    def load_data_ex
+        raise NotImplementedError
+    end
+
+
+    # @note Not implemented yet.
+    #
+    # @see #load
+    def load_fat_binary
+        raise NotImplementedError
+    end
+
+
+    # Unload this CUDA module from the current CUDA context.
+    # @return [CUModule] This CUDA module.
+    def unload
+        status = API::cuModuleUnload(self.to_api)
+        Pvt::handle_error(status, "Failed to unload module.")
+        self
+    end
+
+
+    # Lookup for a CUDA function corresponds to the function name _name_ in the loaded compute module.
+    # A compute module was loaded with {CUModule#load} and alike methods.
+    # @param [String] name The name of the function to lookup in the loaded compute modules.
+    # @return [CUFunction] The CUDA function corresponds to _name_ in the loaded compute module.
+    def function(name)
+        p = FFI::MemoryPointer.new(:CUFunction)
+        status = API::cuModuleGetFunction(p, self.to_api, name)
+        Pvt::handle_error(status, "Failed to get module function: name = #{name}.")
+        CUFunction.send(:new, p)
+    end
+
+
+    # Lookup for the device pointer and the size of the global variable _name_ in the loaded compute modules.
+    # @param [String] name The name of the global variable to lookup in the loaded compute modules.
+    # @return [Array(CUDevicePtr, Integer)] An array with a device pointer to the global variable and its size in bytes.
+    def global(name)
+        pdevptr = FFI::MemoryPointer.new(:CUDevicePtr)
+        psize = FFI::MemoryPointer.new(:size_t)
+        status = API::cuModuleGetGlobal(pdevptr, psize, self.to_api, name)
+        Pvt::handle_error(status, "Failed to get module global: name = #{name}.")
+        [CUDevicePtr.send(:new, pdevptr), API::read_size_t(psize)]
+    end
+
+
+    # @return A texture reference corresponds to the texture _name_ in the loaded compute module.
+    #
+    # @note Not implemented yet.
+    def texref(name)
+        raise NotImplementedError
+    end
+
+
+    # @return A surface texture reference corresponds to the surface _name_ in the loaded compute module.
+    #
+    # @note Not implemented yet.
+    def surfref(name)
+        raise NotImplementedError
+    end
+
+
+    # @private
+    def to_api
+        API::read_cufunction(@pmod)
+    end
+
+end
+
+end # module
+end # module

data/lib/cuda/driver/rubycu.rb

@@ -0,0 +1,37 @@
+#
+# 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 'cuda/driver/ffi-cu'
+require 'cuda/driver/cu'
+require 'cuda/driver/error'
+require 'cuda/driver/init'
+require 'cuda/driver/version'
+require 'cuda/driver/device'
+require 'cuda/driver/context'
+require 'cuda/driver/deviceptr'
+require 'cuda/driver/function'
+require 'cuda/driver/memory'
+require 'cuda/driver/module'
+require 'cuda/driver/stream'
+require 'cuda/driver/event'

data/lib/cuda/driver/stream.rb

@@ -0,0 +1,128 @@
+#
+# 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 'cuda/driver/ffi-cu'
+require 'cuda/driver/error'
+
+
+module SGC
+module CU
+
+class CUStream
+
+    # Create and return a stream with _flags_.
+    # @overload create
+    # @overload create(flags)
+    # @param [Integer] flags Currently _flags_ must be set to zero.
+    # @return [CUStream] A CUDA stream created with _flags_.
+    def self.create(flags = 0)
+        p = FFI::MemoryPointer.new(:CUStream)
+        status = API::cuStreamCreate(p, flags)
+        Pvt::handle_error(status, "Failed to create stream: flags = #{flags}.")
+        new(p)
+    end
+
+
+    # Destroy this CUDA stream.
+    def destroy
+        status = API::cuStreamDestroy(self.to_api)
+        Pvt::handle_error(status, "Failed to destroy stream.")
+        nil
+    end
+
+
+    # @return [Boolean] Return true if all operations in this CUDA stream have completed. Otherwise, return false.
+    def query
+        status = API::cuStreamQuery(self.to_api)
+        if status == Pvt::CUDA_SUCCESS
+            return true
+        elsif status == Pvt::CUDA_ERROR_NOT_READY
+            return false
+        end
+        Pvt::handle_error(status, "Failed to query stream.")
+        raise CUStandardError, "Error handling fails to catch this error."
+    end
+
+
+    # Block the calling CPU thread until all operations in this CUDA stream complete.
+    # @return [CUStream] This CUDA stream.
+    def synchronize
+        status = API::cuStreamSynchronize(self.to_api)
+        Pvt::handle_error(status, "Failed to synchronize stream.")
+        self
+    end
+
+
+    # Let all future operations submitted to this CUDA stream wait until _event_ (CUEvent) complete before beginning execution.
+    # @overload wait_event(event)
+    # @overload wait_event(event, flags)
+    # @param [CUEvent] event The event to wait for.
+    # @param [Integer] flags Currently _flags_ must be set to zero.
+    # @return [CUStream] This CUDA stream.
+    def wait_event(event, flags = 0)
+        status = API::cuStreamWaitEvent(self.to_api, event.to_api, flags)
+        Pvt::handle_error(status, "Failed to make stream's future operations to wait event: flags = #{flags}.")
+        self
+    end
+
+
+    # Let all future operations submitted to any stream in this context wait until _event_ (CUEvent) complete before beginning execution.
+    # @overload wait_event(event)
+    # @overload wait_event(event, flags)
+    # @param (see CUStream#wait_event)
+    def self.wait_event(event, flags = 0)
+        status = API::cuStreamWaitEvent(nil, event.to_api, flags)
+        Pvt::handle_error(status, "Failed to make any stream's future operations to wait event: flags = #{flags}.")
+        nil
+    end
+
+
+    # @private
+    def initialize(ptr)
+        @pstream = ptr
+    end
+    private_class_method :new
+
+
+    # @private
+    def to_api
+        API::read_custream(@pstream)
+    end
+
+end
+
+# @private
+module Pvt
+
+    def self.parse_stream(stream)
+        if stream.kind_of?(CUStream)
+            return stream.to_api
+        end
+        nil
+    end
+
+end
+
+end # module
+end # module

data/lib/cuda/driver/version.rb

@@ -0,0 +1,42 @@
+#
+# 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 'cuda/driver/ffi-cu'
+require 'cuda/driver/error'
+
+
+module SGC
+module CU
+
+# @return [Integer] The CUDA driver version.
+def driver_version
+    p = FFI::MemoryPointer.new(:int)
+    status = API::cuDriverGetVersion(p)
+    Pvt::handle_error(status, "Failed to get the CUDA driver version.")
+    p.read_int
+end
+module_function :driver_version
+
+end # module
+end # module

data/lib/cuda/runtime/cuda.rb

@@ -0,0 +1,65 @@
+#
+# 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'
+require 'memory/buffer'
+
+
+module SGC
+module Cuda
+
+    include SGC::Memory
+
+    class CudaError < API::Enum; end # @see API::CudaError
+    class CudaDeviceFlags < API::Enum; end # @see API::CudaDeviceFlags
+    class CudaEventFlags < API::Enum; end # @see API::CudaEventFlags
+    class CudaHostAllocFlags < API::Enum; end # @see API::CudaHostAllocFlags
+    class CudaHostRegisterFlags < API::Enum; end # @see API::CudaHostRegisterFlags
+    class CudaArrayFlags < API::Enum; end # @see API::CudaArrayFlags
+    class CudaMemoryType < API::Enum; end # @see API::CudaMemoryType
+    class CudaMemcpyKind < API::Enum; end # @see API::CudaMemcpyKind
+    class CudaChannelFormatKind < API::Enum; end # @see API::CudaChannelFormatKind
+    class CudaFunctionCache < API::Enum; end # @see API::CudaFunctionCache
+    class CudaLimit < API::Enum; end # @see API::CudaLimit
+    class CudaOutputMode < API::Enum; end # @see API::CudaOutputMode
+    class CudaComputeMode < API::Enum; end # @see API::CudaComputeMode
+    class CudaSurfaceBoundaryMode < API::Enum; end # @see API::CudaSurfaceBoundaryMode
+    class CudaSurfaceFormatMode < API::Enum; end # @see API::CudaSurfaceFormatMode
+    class CudaTextureAddressMode < API::Enum; end # @see API::CudaTextureAddressMode
+    class CudaTextureFilterMode < API::Enum; end # @see API::CudaTextureFilterMode
+    class CudaTextureReadMode < API::Enum; end # @see API::CudaTextureReadMode
+
+    class Dim3 < API::Dim3; end
+    class CudaDeviceProp < API::CudaDeviceProp; end
+    class CudaFunctionAttributes < API::CudaFunctionAttributes; end
+    class CudaChannelFormatDesc < API::CudaChannelFormatDesc; end
+    class CudaPitchedPtr < API::CudaPitchedPtr; end
+    class CudaPos < API::CudaPos; end
+    class CudaExtent < API::CudaExtent; end
+    class CudaMemcpy3DParms < API::CudaMemcpy3DParms; end
+    class TextureReference < API::TextureReference; end
+    class SurfaceReference < API::SurfaceReference; end
+
+end # module
+end # module

data/lib/cuda/runtime/device.rb

@@ -0,0 +1,175 @@
+#
+# 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'
+require 'cuda/runtime/error'
+
+
+module SGC
+module Cuda
+
+class CudaDevice
+
+    # @return [Integer] The number of CUDA devices.
+    def self.count
+        p = FFI::MemoryPointer.new(:int)
+        status = API::cudaGetDeviceCount(p)
+        Pvt::handle_error(status, "Failed to get device count.")
+        p.read_int
+    end
+
+
+    # @return [Integer] The index of the current CUDA device in use.
+    def self.get
+        p = FFI::MemoryPointer.new(:int)
+        status = API::cudaGetDevice(p)
+        Pvt::handle_error(status, "Failed to get current device.")
+        p.read_int
+    end
+    class << self; alias_method :current, :get; end
+
+
+    # Set _devid_ as the current CUDA device.
+    # @param [Integer] devid The index (0..CudaDevice.count-1) of the CUDA device to set as current.
+    # @return [Class] This class.
+    def self.set(devid)
+        status = API::cudaSetDevice(devid)
+        Pvt::handle_error(status, "Failed to set current device: devid = #{devid}.")
+        self
+    end
+    class << self; alias_method :current=, :set; end
+
+
+    # @param [CudaDeviceProp] prop The criteria for choosing a CUDA device.
+    # @return [Integer] The index of the CUDA device best matches the criteria.
+    def self.choose(prop)
+        pdev = FFI::MemoryPointer.new(:int)
+        status = API::cudaChooseDevice(pdev, prop.to_ptr)
+        Pvt::handle_error(status, "Failed to choose a device with criteria.")
+        pdev.read_int
+    end
+
+
+    # @param [Integer] devid The index of the device to query.
+    # @return [CUDeviceProp] The properties of the device _devid_.
+    def self.properties(devid = self.get)
+        prop = CudaDeviceProp.new
+        status = API::cudaGetDeviceProperties(prop.to_ptr, devid)
+        Pvt::handle_error(status, "Failed to get device properties: devid = #{devid}.")
+        prop
+    end
+
+
+    # Set the flags to be used for device execution.
+    # @param [Integer, CudaDeviceFlags, Array<Integer, CudaDeviceFlags>] flags The flags for device execution.
+    def self.flags=(flags)
+        f = CudaDeviceFlags.value(flags)
+        status = API::cudaSetDeviceFlags(f)
+        Pvt::handle_error(status, "Failed to set device flags: flags = #{flags}.")
+    end
+
+
+    # Set the list of CUDA devices that can be used.
+    # @param [Array] devs The list of CUDA device indexes.
+    def self.valid_devices=(devs)
+        p = FFI::MemoryPointer.new(:int, devs.count)
+        devs.each_with_index do |devid, i|
+            p[i].write_int(devid)
+        end
+        status = API::cudaSetValidDevices(p, devs.count)
+        Pvt::handle_error(status, "Failed to set valid devices: devs = #{devs}.")
+    end
+
+
+    # @return [CudaFunctionCache] The cache config of the current CUDA device.
+    #
+    # @since CUDA 4.0
+    def self.cache_config
+        p = FFI::MemoryPointer.new(:enum)
+        status = API::cudaDeviceGetCacheConfig(p)
+        Pvt::handle_error(status, "Failed to get the current CUDA device cache config.")
+        CudaFunctionCache[API::read_enum(p)]
+    end
+
+
+    # Set the cache config of the current CUDA device to _conf_.
+    # @param [CudaFunctionCache] conf The cache config of the current CUDA device to set to.
+    #
+    # @since CUDA 4.0
+    def self.cache_config=(conf)
+        status = API::cudaDeviceSetCacheConfig(conf)
+        Pvt::handle_error(status, "Failed to set the current CUDA device cache config.")
+    end
+
+
+    # @param [CudaLimit] lim The particular limit attribute to query.
+    # @return [CudaLimit] The limit _lim_ of the current CUDA device.
+    #
+    # @since CUDA 4.0
+    def self.limit(lim)
+        p = FFI::MemoryPointer.new(:size_t)
+        status = API::cudaDeviceGetLimit(p, lim)
+        Pvt::handle_error(status, "Failed to get the current CUDA device limit: limit = #{lim}.")
+        API::read_size_t(p)
+    end
+
+
+    # Set the limit _lim_ of the current CUDA device.
+    # @param [CudaLimit] lim The particular limit attribute to set.
+    # @param [Integer] value The value to set the limit to.
+    #
+    # @since CUDA 4.0
+    def self.limit=(*lim_val_pair)
+        lim, val = lim_val_pair.flatten
+        lim != nil && val != nil or raise ArgumentError, "Invalid limit and value pair given: limit = #{lim}, value = #{val}."
+        status = API::cudaDeviceSetLimit(lim, val)
+        Pvt::handle_error(status, "Failed to set the current CUDA device limit: limit = #{lim}, value = #{val}")
+    end
+
+
+    # Destroy all allocations and reset all state on the current CUDA device.
+    # @return [Class] This class.
+    #
+    # @since CUDA 4.0
+    def self.reset
+        status = API::cudaDeviceReset()
+        Pvt::handle_error(status, "Failed to reset the current CUDA device.")
+        self
+    end
+
+
+    # Block until all the tasks of the current CUDA device complete.
+    # @return [Class] This class.
+    #
+    # @since CUDA 4.0
+    def self.synchronize
+        status = API::cudaDeviceSynchronize()
+        Pvt::handle_error(status, "Failed to synchronize the current CUDA device.")
+        self
+    end
+
+end
+
+end # module
+end # module