sgc-ruby-cuda 0.1.0

data/lib/cuda/driver/cu.rb

@@ -0,0 +1,60 @@
+#
+# 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 'memory/buffer'
+
+
+module SGC
+module CU
+
+    include SGC::Memory
+
+    class CUResult < API::Enum; end # @see API::CUResult
+    class CUComputeMode < API::Enum; end # @see API::CUComputeMode
+    class CUDeviceAttribute < API::Enum; end # @see API::CUDeviceAttribute
+    class CUContextFlags < API::Enum; end # @see API::CUContextFlags
+    class CULimit < API::Enum; end # @see API::CULimit
+    class CUFunctionAttribute < API::Enum; end # @see API::CUFunctionAttribute
+    class CUFunctionCache < API::Enum; end # @see API::CUFunctionCache
+    class CUEventFlags < API::Enum; end # @see API::CUEventFlags
+    class CUAddressMode < API::Enum; end # @see API::CUAddressMode
+    class CUFilterMode < API::Enum; end # @see API::CUFilterMode
+    class CUTexRefFlags < API::Enum; end # @see API::CUTexRefFlags
+    class CUArrayFormat < API::Enum; end # @see API::CUArrayFormat
+    class CUMemoryType < API::Enum; end # @see API::CUMemoryType
+    class CUPointerAttribute < API::Enum; end # @see API::CUPointerAttribute
+    class CUJitOption < API::Enum; end # @see API::CUJitOption
+    class CUJitFallBack < API::Enum; end # @see API::CUJitFallBack
+    class CUJitTarget < API::Enum; end # @see API::CUJitTarget
+
+    class CUDevProp < API::CUDevProp; end
+    class CudaMemcpy2D < API::CudaMemcpy2D; end
+    class CudaMemcpy3D < API::CudaMemcpy3D; end
+    class CudaMemcpy3DPeer < API::CudaMemcpy3DPeer; end
+    class CudaArrayDescriptor < API::CudaArrayDescriptor; end
+    class CudaArray3DDescriptor < API::CudaArray3DDescriptor; end
+
+end # module
+end # module

data/lib/cuda/driver/device.rb

@@ -0,0 +1,155 @@
+#
+# 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'
+
+
+module SGC
+module CU
+
+class CUDevice
+
+    # @return [Integer] The number of CUDA devices.
+    def self.count
+        p = FFI::MemoryPointer.new(:int)
+        status = API::cuDeviceGetCount(p)
+        Pvt::handle_error(status, "Failed to get device count.")
+        p.read_int
+    end
+
+
+    # @param [Integer] index The index (0..CUDevice.count-1) of the device to get.
+    # @return [CUDevice] The device corresponding to CUDA device _index_.
+    def self.get(index)
+        p = FFI::MemoryPointer.new(:CUDevice)
+        status = API::cuDeviceGet(p, index)
+        Pvt::handle_error(status, "Failed to get device #{index}.")
+        new(p)
+    end
+
+
+    # @return [String] The name of this device with a maximum of 255 characters.
+    def name
+        s = FFI::MemoryPointer.new(:char, 256)
+        status = API::cuDeviceGetName(s, 256, self.to_api)
+        Pvt::handle_error(status, "Failed to get device name.")
+        s.read_string
+    end
+
+
+    # @return [Hash{ :major, :minor }] The compute capability of this device.
+    #
+    # @example For a device with compute capability 1.3:
+    #     dev.compute_capability    #=> { major: 1, minor: 3 }
+    def compute_capability
+        cap = FFI::MemoryPointer.new(:int, 2)
+        status = API::cuDeviceComputeCapability(cap[0], cap[1], self.to_api)
+        Pvt::handle_error(status, "Failed to query device compute capability.")
+        { major: cap[0].read_int, minor: cap[1].read_int }
+    end
+
+
+    # @param [CUDeviceAttribute] attrib The particular attribute of this device to query.
+    # @return [Integer] The attribute _attrib_ of this device.
+    #
+    # @example
+    #     dev.attribute(:MAX_THREADS_PER_BLOCK)        #=> 512
+    #     dev.attribute(:MULTIPROCESSOR_COUNT)         #=> 30
+    #     dev.attribute(:MAX_SHARED_MEMORY_PER_BLOCK)  #=> 16384
+    def attribute(attrib)
+        p = FFI::MemoryPointer.new(:int)
+        status = API::cuDeviceGetAttribute(p, attrib, self.to_api)
+        Pvt::handle_error(status, "Failed to query device attribute #{attrib}.")
+        p.read_int
+    end
+
+
+    # @return [Hash] The properties of this device in a hash with the following keys:
+    #     * :clock_rate
+    #     * :max_grid_size
+    #     * :max_threads_dim
+    #     * :max_threads_per_block
+    #     * :mem_pitch
+    #     * :regs_per_block
+    #     * :shared_mem_per_block
+    #     * :simd_width
+    #     * :texture_align
+    #     * :total_constant_memory
+    def properties
+        prop = CUDevProp.new
+        status = API::cuDeviceGetProperties(prop.to_ptr, self.to_api)
+        Pvt::handle_error(status, "Failed to get device properties.")
+        h = {}
+        h[:clock_rate] = prop[:clockRate]
+        h[:max_grid_size] = prop[:maxGridSize]
+        h[:max_threads_dim] = prop[:maxThreadsDim]
+        h[:max_threads_per_block] = prop[:maxThreadsPerBlock]
+        h[:mem_pitch] = prop[:memPitch]
+        h[:regs_per_block] = prop[:regsPerBlock]
+        h[:shared_mem_per_block] = prop[:sharedMemPerBlock]
+        h[:simd_width] = prop[:SIMDWidth]
+        h[:texture_align] = prop[:textureAlign]
+        h[:total_constant_memory] = prop[:totalConstantMemory]
+        h
+    end
+
+
+    # @return [Integer] The total amount of device memory in bytes.
+    def total_mem
+        p = FFI::MemoryPointer.new(:size_t)
+        status = API::cuDeviceTotalMem(p, self.to_api)
+        Pvt::handle_error(status, "Failed to get device total amount of memory available.")
+        API::read_size_t(p)
+    end
+
+
+    # Allocate _nbytes_ of device memory from the current device.
+    # @param [Integer] nbytes The number of bytes to allocate.
+    # @return [CUDevicePtr] A device pointer to the allocated memory.
+    def self.malloc(nbytes)
+        p = FFI::MemoryPointer.new(:CUDevicePtr)
+        status = API::cuMemAlloc(p, nbytes)
+        Pvt::handle_error(status, "Failed to allocate device memory: size = #{nbytes}.")
+        CUDevicePtr.send(:new, p)
+    end
+
+
+    # @private
+    def initialize(ptr)
+        @pdev = ptr
+    end
+    private_class_method :new
+
+
+    # @private
+    def to_api
+        API::read_cudevice(@pdev)
+    end
+
+end
+
+end # module
+end # module

data/lib/cuda/driver/deviceptr.rb

@@ -0,0 +1,69 @@
+#
+# 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 CUDevicePtr
+
+    # Free the allocated device memory that this pointer pointing to.
+    def free
+        status = API::cuMemFree(API::read_cudeviceptr(@pdevptr))
+        Pvt::handle_error(status, "Failed to free device memory.")
+        API::write_cudeviceptr(@pdevptr, 0)
+        nil
+    end
+
+
+    # @param [Integer] index Number of bytes to offset from this pointer address.
+    # @return [CUDevicePtr] A pointer pointing to the memory location _index_ (bytes)
+    #   from this pointer address.
+    def offset(index)
+        p = FFI::MemoryPointer.new(:CUDevicePtr)
+        addr = API::read_cudeviceptr(@pdevptr).to_i + index
+        API::write_cudeviceptr(p, addr)
+        CUDevicePtr.send(:new, p)
+    end
+
+
+    # @private
+    def initialize(ptr)
+        @pdevptr = ptr
+    end
+    private_class_method :new
+
+
+    # @private
+    def to_api
+        API::read_cudeviceptr(@pdevptr)
+    end
+
+end
+
+end # module
+end # module

data/lib/cuda/driver/error.rb

@@ -0,0 +1,182 @@
+#
+#   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'
+
+
+module SGC
+module CU
+
+    module Error
+
+        class CUStandardError < RuntimeError; end
+
+        class CUDeviceError < CUStandardError; end
+        class CUDeviceNotInitializedError < CUDeviceError; end
+        class CUDeviceDeinitializedError < CUDeviceError; end
+        class CUNoDeviceError < CUDeviceError; end
+        class CUInvalidDeviceError < CUDeviceError; end
+
+        class CUMapError < CUStandardError; end
+        class CUMapFailedError < CUMapError; end
+        class CUUnMapFailedError < CUMapError; end
+        class CUArrayIsMappedError < CUMapError; end
+        class CUAlreadyMappedError < CUMapError; end
+        class CUNotMappedError < CUMapError; end
+        class CUNotMappedAsArrayError < CUMapError; end
+        class CUNotMappedAsPointerError < CUMapError; end
+
+        class CUContextError < CUStandardError; end
+        class CUInvalidContextError < CUContextError; end
+        class CUContextAlreadyCurrentError < CUContextError; end # @deprecated
+        class CUContextAlreadyInUseError < CUContextError; end
+        class CUUnsupportedLimitError < CUContextError; end
+        class CUPrimaryContextActiveError < CUContextError; end
+        class CUContextIsDestroyedError < CUContextError; end
+
+        class CULaunchError < CUStandardError; end
+        class CULaunchFailedError < CULaunchError; end
+        class CULaunchOutOfResourcesError < CULaunchError; end
+        class CULaunchTimeoutError < CULaunchError; end
+        class CULaunchIncompatibleTexturingError < CULaunchError; end
+
+        class CUParameterError < CUStandardError; end
+        class CUInvalidValueError < CUParameterError; end
+        class CUInvalidHandleError < CUParameterError; end
+
+        class CUMemoryError < CUStandardError; end
+        class CUOutOfMemoryError < CUMemoryError; end
+
+        class CUPeerAccessError < CUStandardError; end
+        class CUPeerAccessAlreadyEnabledError < CUPeerAccessError; end
+        class CUPeerAccessNotEnabledError < CUPeerAccessError; end
+
+        class CULibraryError < CUStandardError; end
+        class CUSharedObjectSymbolNotFoundError < CULibraryError; end
+        class CUSharedObjectInitFailedError < CULibraryError; end
+
+        class CUHardwareError < CUStandardError; end
+        class CUECCUncorrectableError < CUHardwareError; end
+
+        class CUFileError < CUStandardError; end
+        class CUNoBinaryForGPUError < CUFileError; end
+        class CUFileNotFoundError < CUFileError; end
+        class CUInvalidSourceError < CUFileError; end
+        class CUInvalidImageError < CUFileError; end
+
+        class CUReferenceError < CUStandardError; end
+        class CUReferenceNotFoundError < CUReferenceError; end
+
+        class CUProfilerError < CUStandardError; end
+        class CUProfilerDisabledError < CUProfilerError; end
+        class CUProfilerNotInitializedError < CUProfilerError; end
+        class CUProfilerAlreadyStartedError < CUProfilerError; end
+        class CUProfilerAlreadyStoppedError < CUProfilerError; end
+
+        class CUOtherError < CUStandardError; end
+        class CUAlreadyAcquiredError < CUOtherError; end
+        class CUNotReadyError < CUOtherError; end
+        class CUOperatingSystemError < CUOtherError; end
+
+        class CUUnknownError < CUStandardError; end
+
+    end
+
+
+    # @private
+    module Pvt
+
+        include Error
+
+        def self.handle_error(status, msg = nil)
+            status == CUDA_SUCCESS or raise @error_class_by_enum[API::CUResult[status]], msg
+            nil
+        end
+
+
+        CUDA_SUCCESS = API::CUResult[:SUCCESS]
+        CUDA_ERROR_NOT_READY = API::CUResult[:ERROR_NOT_READY]
+
+        @error_class_by_enum = {
+            ERROR_NOT_INITIALIZED: CUDeviceNotInitializedError,
+            ERROR_DEINITIALIZED: CUDeviceDeinitializedError,
+            ERROR_NO_DEVICE: CUNoDeviceError,
+            ERROR_INVALID_DEVICE: CUInvalidDeviceError,
+
+            ERROR_MAP_FAILED: CUMapFailedError,
+            ERROR_UNMAP_FAILED: CUUnMapFailedError,
+            ERROR_ARRAY_IS_MAPPED: CUArrayIsMappedError,
+            ERROR_ALREADY_MAPPED: CUAlreadyMappedError,
+            ERROR_NOT_MAPPED: CUNotMappedError,
+            ERROR_NOT_MAPPED_AS_ARRAY: CUNotMappedAsArrayError,
+            ERROR_NOT_MAPPED_AS_POINTER: CUNotMappedAsPointerError,
+
+            ERROR_INVALID_CONTEXT: CUInvalidContextError,
+            ERROR_CONTEXT_ALREADY_CURRENT: CUContextAlreadyCurrentError,
+            ERROR_CONTEXT_ALREADY_IN_USE: CUContextAlreadyInUseError,
+            ERROR_UNSUPPORTED_LIMIT: CUUnsupportedLimitError,
+            ERROR_PRIMARY_CONTEXT_ACTIVE: CUPrimaryContextActiveError,
+            ERROR_CONTEXT_IS_DESTROYED: CUContextIsDestroyedError,
+
+            ERROR_LAUNCH_FAILED: CULaunchFailedError,
+            ERROR_LAUNCH_OUT_OF_RESOURCES: CULaunchOutOfResourcesError,
+            ERROR_LAUNCH_TIMEOUT: CULaunchTimeoutError,
+            ERROR_LAUNCH_INCOMPATIBLE_TEXTURING: CULaunchIncompatibleTexturingError,
+
+            ERROR_INVALID_VALUE: CUInvalidValueError,
+            ERROR_INVALID_HANDLE: CUInvalidHandleError,
+
+            ERROR_OUT_OF_MEMORY: CUOutOfMemoryError,
+
+            ERROR_PEER_ACCESS_ALREADY_ENABLED: CUPeerAccessAlreadyEnabledError,
+            ERROR_PEER_ACCESS_NOT_ENABLED: CUPeerAccessNotEnabledError,
+
+            ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND: CUSharedObjectSymbolNotFoundError,
+            ERROR_SHARED_OBJECT_INIT_FAILED: CUSharedObjectInitFailedError,
+
+            ERROR_ECC_UNCORRECTABLE: CUECCUncorrectableError,
+
+            ERROR_NO_BINARY_FOR_GPU: CUNoBinaryForGPUError,
+            ERROR_FILE_NOT_FOUND: CUFileNotFoundError,
+            ERROR_INVALID_SOURCE: CUInvalidSourceError,
+            ERROR_INVALID_IMAGE: CUInvalidImageError,
+
+            ERROR_NOT_FOUND: CUReferenceNotFoundError,
+
+            ERROR_PROFILER_DISABLED: CUProfilerDisabledError,
+            ERROR_PROFILER_NOT_INITIALIZED: CUProfilerNotInitializedError,
+            ERROR_PROFILER_ALREADY_STARTED: CUProfilerAlreadyStartedError,
+            ERROR_PROFILER_ALREADY_STOPPED: CUProfilerAlreadyStoppedError,
+
+            ERROR_ALREADY_ACQUIRED: CUAlreadyAcquiredError,
+            ERROR_NOT_READY: CUNotReadyError,
+            ERROR_OPERATING_SYSTEM: CUOperatingSystemError,
+
+            ERROR_UNKNOWN: CUUnknownError,
+        }
+
+    end
+
+end # module
+end # module