sgc-ruby-cuda 0.1.0 → 0.1.1

data/README.rdoc

@@ -54,6 +54,20 @@ interpretors.
 
 == How to get SGC-Ruby-CUDA
 
+The SGC-Ruby-CUDA Ruby gem is available at rubygems.org and rubyforge.org:
+
+    # Install the gem with the following command.
+    $ gem install sgc-ruby-cuda
+
+        or
+
+    # Download the gem from the following URL and install.
+    http://rubyforge.org/frs/?group_id=9719
+
+The online documentations are available at the following:
+
+    http://rubydoc.info/github/xman/sgc-ruby-cuda/master/frames
+
 The SGC-Ruby-CUDA git repository can be found in the following:
 
     http://github.com/xman/sgc-ruby-cuda
@@ -76,12 +90,18 @@ minimize unnecessary fixing commits.
     # Setup the environment. Assuming the CUDA Toolkit is installed in
     # the default path /usr/local/cuda.
 
-    # For 64bit Linux:
+    # For 64bit Linux only:
     export CPATH="/usr/local/cuda/include"
     export LIBRARY_PATH="/usr/local/cuda/lib64"
     export LD_LIBRARY_PATH="/usr/local/cuda/lib64:$LD_LIBRARY_PATH"
     export PATH="/usr/local/cuda/bin:$PATH"
 
+    # For Mac OSX only:
+    export CPATH="/usr/local/cuda/include"
+    export LIBRARY_PATH="/usr/local/cuda/lib"
+    export DYLD_LIBRARY_PATH="/usr/local/cuda/lib:$DYLD_LIBRARY_PATH"
+    export PATH="/usr/local/cuda/bin:$PATH"
+
     gem install ffi
     cd sgc-ruby-cuda
     rake test
@@ -93,6 +113,31 @@ minimize unnecessary fixing commits.
     # Check out the generated documentations in html/index.html with a browser.
 
 
+== How to contribute
+
+1. Create an account in github http://github.com
+2. Fork this project SGC-Ruby-CUDA at http://github.com/xman/sgc-ruby-cuda
+3. Make changes and submit commits to your local repository.
+4. At your local repository, setup and send a pull request.
+
+Ideally, a commit should do only one task. We like clean commits.
+Commits should be applied to the master branch.
+
+
+== How to file a bug report
+
+Submit new issues at https://github.com/xman/sgc-ruby-cuda/issues
+
+Please provide information on the SGC-Ruby-CUDA version or the commit hash,
+OS platform, Ruby version, FFI version, how to reproduce the issue, the error
+messages.
+
+
+== Mailing list
+
+http://groups.google.com/group/sgc-ruby-cuda
+
+
 == License
 
 SGC-Ruby-CUDA is released under the GNU GPLv3. See the file COPYING.

data/doc/features.rdoc

@@ -12,7 +12,7 @@
     Module Management                   +
     Memory Management                   +
     Unified Addressing                  -
-    Peer Context Memory Access          -
+    Peer Context Memory Access          *
     Execution Control                   +
     Stream Management                   *
     Event Management                    *
@@ -40,7 +40,7 @@
     Thread Management                   *
     Memory Management                   +
     Unified Addressing                  -
-    Peer Device Memory Access           -
+    Peer Device Memory Access           *
     Execution Control                   +
     Stream Management                   *
     Event Management                    *

data/lib/cuda/driver/context.rb

@@ -218,6 +218,31 @@ class CUContext
     end
 
 
+    # Enable the current context to access the memory of the peer context.
+    # @param [CUContext] peer_context The peer context's memory to be accessed.
+    # @param [Integer] flags Currently flags must be set to zero.
+    # @return [Class] This class.
+    #
+    # @since CUDA 4.0
+    def self.enable_peer_access(peer_context, flags = 0)
+        status = API::cuCtxEnablePeerAccess(peer_context.to_api, flags)
+        Pvt::handle_error(status, "Failed to enable peer access: flags = #{flags}.")
+        self
+    end
+
+
+    # Disable the current context from accessing the memory of the peer context.
+    # @param [CUContext] peer_context The peer context.
+    # @return [Class] This class.
+    #
+    # @since CUDA 4.0
+    def self.disable_peer_access(peer_context)
+        status = API::cuCtxDisablePeerAccess(peer_context.to_api)
+        Pvt::handle_error(status, "Failed to disable peer access.")
+        self
+    end
+
+
     # @private
     def initialize(ptr)
         @pcontext = ptr

data/lib/cuda/driver/cu.rb

@@ -22,8 +22,10 @@
 # along with SGC-Ruby-CUDA.  If not, see <http://www.gnu.org/licenses/>.
 #
 
+require 'delegate'
 require 'cuda/driver/ffi-cu'
 require 'memory/buffer'
+require 'helpers/struct'
 
 
 module SGC
@@ -42,19 +44,26 @@ module CU
     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 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
+    class CUDevProp < DelegateClass(API::CUDevProp); end # See {file:lib/cuda/driver/ffi-cu.rb}
+    class CudaMemcpy2D < DelegateClass(API::CudaMemcpy2D); end # See {file:lib/cuda/driver/ffi-cu.rb}
+    class CudaMemcpy3D < DelegateClass(API::CudaMemcpy3D); end  # See {file:lib/cuda/driver/ffi-cu.rb}
+    class CudaMemcpy3DPeer < DelegateClass(API::CudaMemcpy3DPeer); end # See {file:lib/cuda/driver/ffi-cu.rb}
+    class CudaArrayDescriptor < DelegateClass(API::CudaArrayDescriptor); end # See {file:lib/cuda/driver/ffi-cu.rb}
+    class CudaArray3DDescriptor < DelegateClass(API::CudaArray3DDescriptor); end # See {file:lib/cuda/driver/ffi-cu.rb}
+
+    SGC::Helper::Struct::Pvt::define_delegated_struct_methods(CUDevProp, API::CUDevProp)
+    SGC::Helper::Struct::Pvt::define_delegated_struct_methods(CudaMemcpy2D, API::CudaMemcpy2D)
+    SGC::Helper::Struct::Pvt::define_delegated_struct_methods(CudaMemcpy3D, API::CudaMemcpy3D)
+    SGC::Helper::Struct::Pvt::define_delegated_struct_methods(CudaMemcpy3DPeer, API::CudaMemcpy3DPeer)
+    SGC::Helper::Struct::Pvt::define_delegated_struct_methods(CudaArrayDescriptor, API::CudaArrayDescriptor)
+    SGC::Helper::Struct::Pvt::define_delegated_struct_methods(CudaArray3DDescriptor, API::CudaArray3DDescriptor)
 
 end # module
 end # module

data/lib/cuda/driver/device.rb

@@ -25,6 +25,7 @@
 require 'cuda/driver/ffi-cu'
 require 'cuda/driver/cu'
 require 'cuda/driver/error'
+require 'cuda/driver/context'
 
 
 module SGC
@@ -99,7 +100,7 @@ class CUDevice
     #     * :texture_align
     #     * :total_constant_memory
     def properties
-        prop = CUDevProp.new
+        prop = API::CUDevProp.new
         status = API::cuDeviceGetProperties(prop.to_ptr, self.to_api)
         Pvt::handle_error(status, "Failed to get device properties.")
         h = {}
@@ -137,6 +138,24 @@ class CUDevice
     end
 
 
+    # @param [CUDevice] dev The device which is to access the memory of the device _peer_dev_.
+    # @param [CUDevice] peer_dev The device which its memory is to be accessed by the device _dev_.
+    # @return [Boolean] True if device _dev_ may directly access the memory of device _peer_dev_.
+    #
+    # @since CUDA 4.0
+    def self.can_access_peer?(dev, peer_dev = nil)
+        # TODO: Remove the following workaround for JRuby when the default argument bug is fixed.
+        if peer_dev.nil?
+            peer_dev = dev
+            dev = CUContext.device
+        end
+        b = FFI::MemoryPointer.new(:int)
+        status = API::cuDeviceCanAccessPeer(b, dev.to_api, peer_dev.to_api)
+        Pvt::handle_error(status, "Failed to query can access peer.")
+        b.read_int == 1 ? true : false
+    end
+
+
     # @private
     def initialize(ptr)
         @pdev = ptr

data/lib/cuda/driver/ffi-cu.rb

@@ -24,6 +24,7 @@
 
 require 'ffi'
 require 'ffi/prettystruct'
+require 'ffi/typedef'
 require 'helpers/interface/ienum'
 require 'helpers/flags'
 require 'helpers/klass'
@@ -268,7 +269,7 @@ module API
 
     FFI::typedef :int, :enum
     FFI::typedef :int, :CUDevice
-    FFI::typedef :pointer, :CUDevicePtr
+    FFI::typedef :ulong_long, :CUDevicePtr
     FFI::typedef :pointer, :CUContext
     FFI::typedef :pointer, :CUModule
     FFI::typedef :pointer, :CUFunction
@@ -280,16 +281,18 @@ module API
 
     def read_int(ptr); ptr.read_int; end
     def read_long(ptr); ptr.read_long; end
+    def read_ulong_long(ptr); ptr.read_ulong_long; end
     def read_pointer(ptr); ptr.read_pointer; end
 
-    def write_int(ptr); ptr.write_int; end
-    def write_long(ptr); ptr.write_long; end
-    def write_pointer(ptr, value); ptr.write_pointer(value); end
+    def write_int(ptr, value); ptr.write_int(value); end
+    def write_long(ptr, value); ptr.write_long(value); end
+    def write_ulong_long(ptr, value); ptr.write_ulong_long(value); end
+    def write_pointer(ptr, value); ptr.write_long(value.to_i); end
 
     alias read_size_t read_long
     alias read_enum read_int
     alias read_cudevice read_int
-    alias read_cudeviceptr read_pointer
+    alias read_cudeviceptr read_ulong_long
     alias read_cucontext read_pointer
     alias read_cumodule read_pointer
     alias read_cufunction read_pointer
@@ -302,7 +305,7 @@ module API
     alias write_size_t write_long
     alias write_enum write_int
     alias write_cudevice write_int
-    alias write_cudeviceptr write_pointer
+    alias write_cudeviceptr write_ulong_long
     alias write_cucontext write_pointer
     alias write_cumodule write_pointer
     alias write_cufunction write_pointer
@@ -468,92 +471,132 @@ module API
     attach_function :cuDeviceGetCount, [:pointer], :enum
     attach_function :cuDeviceGetName, [:pointer, :int, :CUDevice], :enum
     attach_function :cuDeviceGetProperties, [:pointer, :CUDevice], :enum
-    attach_function :cuDeviceTotalMem, [:pointer, :CUDevice], :enum
+    attach_function :cuDeviceTotalMem_v2, [:pointer, :CUDevice], :enum
+    class << self; alias_method :cuDeviceTotalMem, :cuDeviceTotalMem_v2; end
 
     # CU Context Management.
-    attach_function :cuCtxCreate, [:pointer, :uint, :CUDevice], :enum
-    attach_function :cuCtxDestroy, [:CUContext], :enum
+    attach_function :cuCtxCreate_v2, [:pointer, :uint, :CUDevice], :enum
+    attach_function :cuCtxDestroy_v2, [:CUContext], :enum
     attach_function :cuCtxGetApiVersion, [:CUContext, :pointer], :enum
     attach_function :cuCtxGetCacheConfig, [:pointer], :enum
     attach_function :cuCtxGetCurrent, [:pointer], :enum
     attach_function :cuCtxGetDevice, [:pointer], :enum
     attach_function :cuCtxGetLimit, [:pointer, CULimit], :enum
-    attach_function :cuCtxPopCurrent, [:pointer], :enum
-    attach_function :cuCtxPushCurrent, [:CUContext], :enum
+    attach_function :cuCtxPopCurrent_v2, [:pointer], :enum
+    attach_function :cuCtxPushCurrent_v2, [:CUContext], :enum
     attach_function :cuCtxSetCacheConfig, [CUFunctionCache], :enum
     attach_function :cuCtxSetCurrent, [:CUContext], :enum
     attach_function :cuCtxSetLimit, [CULimit, :size_t], :enum
     attach_function :cuCtxSynchronize, [], :enum
+    class << self; alias_method :cuCtxDestroy, :cuCtxDestroy_v2; end
+    class << self; alias_method :cuCtxCreate, :cuCtxCreate_v2; end
+    class << self; alias_method :cuCtxPopCurrent, :cuCtxPopCurrent_v2; end
+    class << self; alias_method :cuCtxPushCurrent, :cuCtxPushCurrent_v2; end
     # Deprecated.
     attach_function :cuCtxAttach, [:pointer, :uint], :enum
     attach_function :cuCtxDetach, [:CUContext], :enum
 
     # CU Memory Management.
-    attach_function :cuArray3DCreate, [:pointer, :pointer], :enum
-    attach_function :cuArray3DGetDescriptor, [:pointer, :CUArray], :enum
-    attach_function :cuArrayCreate, [:pointer, :pointer], :enum
+    attach_function :cuArray3DCreate_v2, [:pointer, :pointer], :enum
+    attach_function :cuArray3DGetDescriptor_v2, [:pointer, :CUArray], :enum
+    attach_function :cuArrayCreate_v2, [:pointer, :pointer], :enum
     attach_function :cuArrayDestroy, [:CUArray], :enum
-    attach_function :cuArrayGetDescriptor, [:pointer, :CUArray], :enum
-    attach_function :cuMemAlloc, [:pointer, :size_t], :enum
-    attach_function :cuMemAllocHost, [:pointer, :size_t], :enum
-    attach_function :cuMemAllocPitch, [:pointer, :pointer, :size_t, :size_t, :uint], :enum
+    attach_function :cuArrayGetDescriptor_v2, [:pointer, :CUArray], :enum
+    attach_function :cuMemAlloc_v2, [:pointer, :size_t], :enum
+    attach_function :cuMemAllocHost_v2, [:pointer, :size_t], :enum
+    attach_function :cuMemAllocPitch_v2, [:pointer, :pointer, :size_t, :size_t, :uint], :enum
     attach_function :cuMemcpy, [:CUDevicePtr, :CUDevicePtr, :size_t], :enum
-    attach_function :cuMemcpy2D, [:pointer], :enum
-    attach_function :cuMemcpy2DAsync, [:pointer, :CUStream], :enum
-    attach_function :cuMemcpy2DUnaligned, [:pointer], :enum
-    attach_function :cuMemcpy3D, [:pointer], :enum
-    attach_function :cuMemcpy3DAsync, [:pointer, :CUStream], :enum
+    attach_function :cuMemcpy2D_v2, [:pointer], :enum
+    attach_function :cuMemcpy2DAsync_v2, [:pointer, :CUStream], :enum
+    attach_function :cuMemcpy2DUnaligned_v2, [:pointer], :enum
+    attach_function :cuMemcpy3D_v2, [:pointer], :enum
+    attach_function :cuMemcpy3DAsync_v2, [:pointer, :CUStream], :enum
     attach_function :cuMemcpy3DPeer, [:pointer], :enum
     attach_function :cuMemcpy3DPeerAsync, [:pointer, :CUStream], :enum
     attach_function :cuMemcpyAsync, [:CUDevicePtr, :CUDevicePtr, :size_t, :CUStream], :enum
-    attach_function :cuMemcpyAtoA, [:CUArray, :size_t, :CUArray, :size_t, :size_t], :enum
-    attach_function :cuMemcpyAtoD, [:CUDevicePtr, :CUArray, :size_t, :size_t], :enum
-    attach_function :cuMemcpyAtoH, [:pointer, :CUArray, :size_t, :size_t], :enum
-    attach_function :cuMemcpyAtoHAsync, [:pointer, :CUArray, :size_t, :size_t, :CUStream], :enum
-    attach_function :cuMemcpyDtoA, [:CUArray, :size_t, :CUDevicePtr, :size_t], :enum
-    attach_function :cuMemcpyDtoD, [:CUDevicePtr, :CUDevicePtr, :size_t], :enum
-    attach_function :cuMemcpyDtoDAsync, [:CUDevicePtr, :CUDevicePtr, :size_t, :CUStream], :enum
-    attach_function :cuMemcpyDtoH, [:pointer, :CUDevicePtr, :size_t], :enum
-    attach_function :cuMemcpyDtoHAsync, [:pointer, :CUDevicePtr, :size_t, :CUStream], :enum
-    attach_function :cuMemcpyHtoA, [:CUArray, :size_t, :pointer, :size_t], :enum
-    attach_function :cuMemcpyHtoAAsync, [:CUArray, :size_t, :pointer, :size_t, :CUStream], :enum
-    attach_function :cuMemcpyHtoD, [:CUDevicePtr, :pointer, :size_t], :enum
-    attach_function :cuMemcpyHtoDAsync, [:CUDevicePtr, :pointer, :size_t, :CUStream], :enum
+    attach_function :cuMemcpyAtoA_v2, [:CUArray, :size_t, :CUArray, :size_t, :size_t], :enum
+    attach_function :cuMemcpyAtoD_v2, [:CUDevicePtr, :CUArray, :size_t, :size_t], :enum
+    attach_function :cuMemcpyAtoH_v2, [:pointer, :CUArray, :size_t, :size_t], :enum
+    attach_function :cuMemcpyAtoHAsync_v2, [:pointer, :CUArray, :size_t, :size_t, :CUStream], :enum
+    attach_function :cuMemcpyDtoA_v2, [:CUArray, :size_t, :CUDevicePtr, :size_t], :enum
+    attach_function :cuMemcpyDtoD_v2, [:CUDevicePtr, :CUDevicePtr, :size_t], :enum
+    attach_function :cuMemcpyDtoDAsync_v2, [:CUDevicePtr, :CUDevicePtr, :size_t, :CUStream], :enum
+    attach_function :cuMemcpyDtoH_v2, [:pointer, :CUDevicePtr, :size_t], :enum
+    attach_function :cuMemcpyDtoHAsync_v2, [:pointer, :CUDevicePtr, :size_t, :CUStream], :enum
+    attach_function :cuMemcpyHtoA_v2, [:CUArray, :size_t, :pointer, :size_t], :enum
+    attach_function :cuMemcpyHtoAAsync_v2, [:CUArray, :size_t, :pointer, :size_t, :CUStream], :enum
+    attach_function :cuMemcpyHtoD_v2, [:CUDevicePtr, :pointer, :size_t], :enum
+    attach_function :cuMemcpyHtoDAsync_v2, [:CUDevicePtr, :pointer, :size_t, :CUStream], :enum
     attach_function :cuMemcpyPeer, [:CUDevicePtr, :CUContext, :CUDevicePtr, :CUContext, :size_t], :enum
     attach_function :cuMemcpyPeerAsync, [:CUDevicePtr, :CUContext, :CUDevicePtr, :CUContext, :size_t, :CUStream], :enum
-    attach_function :cuMemFree, [:CUDevicePtr], :enum
+    attach_function :cuMemFree_v2, [:CUDevicePtr], :enum
     attach_function :cuMemFreeHost, [:pointer], :enum
-    attach_function :cuMemGetAddressRange, [:pointer, :pointer, :CUDevicePtr], :enum
-    attach_function :cuMemGetInfo, [:pointer, :pointer], :enum
+    attach_function :cuMemGetAddressRange_v2, [:pointer, :pointer, :CUDevicePtr], :enum
+    attach_function :cuMemGetInfo_v2, [:pointer, :pointer], :enum
     attach_function :cuMemHostAlloc, [:pointer, :size_t, :uint], :enum
-    attach_function :cuMemHostGetDevicePointer, [:pointer, :pointer, :uint], :enum
+    attach_function :cuMemHostGetDevicePointer_v2, [:pointer, :pointer, :uint], :enum
     attach_function :cuMemHostGetFlags, [:pointer, :pointer], :enum
     attach_function :cuMemHostRegister, [:pointer, :size_t, :uint], :enum
     attach_function :cuMemHostUnregister, [:pointer], :enum
-    attach_function :cuMemsetD16, [:CUDevicePtr, :ushort, :size_t], :enum
+    attach_function :cuMemsetD16_v2, [:CUDevicePtr, :ushort, :size_t], :enum
     attach_function :cuMemsetD16Async, [:CUDevicePtr, :ushort, :size_t, :CUStream], :enum
-    attach_function :cuMemsetD2D16, [:CUDevicePtr, :size_t, :ushort, :size_t, :size_t], :enum
+    attach_function :cuMemsetD2D16_v2, [:CUDevicePtr, :size_t, :ushort, :size_t, :size_t], :enum
     attach_function :cuMemsetD2D16Async, [:CUDevicePtr, :size_t, :ushort, :size_t, :size_t, :CUStream], :enum
-    attach_function :cuMemsetD2D32, [:CUDevicePtr, :size_t, :uint, :size_t, :size_t], :enum
+    attach_function :cuMemsetD2D32_v2, [:CUDevicePtr, :size_t, :uint, :size_t, :size_t], :enum
     attach_function :cuMemsetD2D32Async, [:CUDevicePtr, :size_t, :uint, :size_t, :size_t, :CUStream], :enum
-    attach_function :cuMemsetD2D8, [:CUDevicePtr, :size_t, :uchar, :size_t, :size_t], :enum
+    attach_function :cuMemsetD2D8_v2, [:CUDevicePtr, :size_t, :uchar, :size_t, :size_t], :enum
     attach_function :cuMemsetD2D8Async, [:CUDevicePtr, :size_t, :uchar, :size_t, :size_t, :CUStream], :enum
-    attach_function :cuMemsetD32, [:CUDevicePtr, :uint, :size_t], :enum
+    attach_function :cuMemsetD32_v2, [:CUDevicePtr, :uint, :size_t], :enum
     attach_function :cuMemsetD32Async, [:CUDevicePtr, :uint, :size_t, :CUStream], :enum
-    attach_function :cuMemsetD8, [:CUDevicePtr, :uchar, :size_t], :enum
+    attach_function :cuMemsetD8_v2, [:CUDevicePtr, :uchar, :size_t], :enum
     attach_function :cuMemsetD8Async, [:CUDevicePtr, :uchar, :size_t, :CUStream], :enum
+    class << self; alias_method :cuArray3DCreate, :cuArray3DCreate_v2; end
+    class << self; alias_method :cuArray3DGetDescriptor, :cuArray3DGetDescriptor_v2; end
+    class << self; alias_method :cuArrayCreate, :cuArrayCreate_v2; end
+    class << self; alias_method :cuArrayGetDescriptor, :cuArrayGetDescriptor_v2; end
+    class << self; alias_method :cuMemAlloc, :cuMemAlloc_v2; end
+    class << self; alias_method :cuMemAllocHost, :cuMemAllocHost_v2; end
+    class << self; alias_method :cuMemAllocPitch, :cuMemAllocPitch_v2; end
+    class << self; alias_method :cuMemcpy2D, :cuMemcpy2D_v2; end
+    class << self; alias_method :cuMemcpy2DAsync, :cuMemcpy2DAsync_v2 ; end
+    class << self; alias_method :cuMemcpy2DUnaligned, :cuMemcpy2DUnaligned_v2; end
+    class << self; alias_method :cuMemcpy3D, :cuMemcpy3D_v2; end
+    class << self; alias_method :cuMemcpy3DAsync, :cuMemcpy3DAsync_v2; end
+    class << self; alias_method :cuMemcpyAtoA, :cuMemcpyAtoA_v2; end
+    class << self; alias_method :cuMemcpyAtoD, :cuMemcpyAtoD_v2; end
+    class << self; alias_method :cuMemcpyAtoH, :cuMemcpyAtoH_v2; end
+    class << self; alias_method :cuMemcpyAtoHAsync, :cuMemcpyAtoHAsync_v2; end
+    class << self; alias_method :cuMemcpyDtoA, :cuMemcpyDtoA_v2; end
+    class << self; alias_method :cuMemcpyDtoD, :cuMemcpyDtoD_v2; end
+    class << self; alias_method :cuMemcpyDtoDAsync, :cuMemcpyDtoDAsync_v2; end
+    class << self; alias_method :cuMemcpyDtoH, :cuMemcpyDtoH_v2; end
+    class << self; alias_method :cuMemcpyDtoHAsync, :cuMemcpyDtoHAsync_v2; end
+    class << self; alias_method :cuMemcpyHtoA, :cuMemcpyHtoA_v2; end
+    class << self; alias_method :cuMemcpyHtoAAsync, :cuMemcpyHtoAAsync_v2; end
+    class << self; alias_method :cuMemcpyHtoD, :cuMemcpyHtoD_v2; end
+    class << self; alias_method :cuMemcpyHtoDAsync, :cuMemcpyHtoDAsync_v2; end
+    class << self; alias_method :cuMemFree, :cuMemFree_v2; end
+    class << self; alias_method :cuMemGetAddressRange, :cuMemGetAddressRange_v2; end
+    class << self; alias_method :cuMemGetInfo, :cuMemGetInfo_v2; end
+    class << self; alias_method :cuMemHostGetDevicePointer, :cuMemHostGetDevicePointer_v2; end
+    class << self; alias_method :cuMemsetD16, :cuMemsetD16_v2; end
+    class << self; alias_method :cuMemsetD2D16, :cuMemsetD2D16_v2; end
+    class << self; alias_method :cuMemsetD2D32, :cuMemsetD2D32_v2; end
+    class << self; alias_method :cuMemsetD2D8, :cuMemsetD2D8_v2; end
+    class << self; alias_method :cuMemsetD32, :cuMemsetD32_v2; end
+    class << self; alias_method :cuMemsetD8, :cuMemsetD8_v2; end
 
     # CU Unified Addressing.
     attach_function :cuPointerGetAttribute, [:pointer, CUPointerAttribute, :CUDevicePtr], :enum
 
     # CU Peer Context Memory Access.
     attach_function :cuCtxDisablePeerAccess, [:CUContext], :enum
-    attach_function :cuCtxEnablePeerAccess, [:CUContext], :enum
+    attach_function :cuCtxEnablePeerAccess, [:CUContext, :uint], :enum
     attach_function :cuDeviceCanAccessPeer, [:pointer, :CUDevice, :CUDevice], :enum
 
     # CU Module Management.
     attach_function :cuModuleGetFunction, [:pointer, :CUModule, :string], :enum
-    attach_function :cuModuleGetGlobal, [:pointer, :pointer, :CUModule, :string], :enum
+    attach_function :cuModuleGetGlobal_v2, [:pointer, :pointer, :CUModule, :string], :enum
     attach_function :cuModuleGetSurfRef, [:pointer, :CUModule, :string], :enum
     attach_function :cuModuleGetTexRef, [:pointer, :CUModule, :string], :enum
     attach_function :cuModuleLoad, [:pointer, :string], :enum
@@ -561,6 +604,7 @@ module API
     attach_function :cuModuleLoadDataEx, [:pointer, :pointer, :uint, :pointer, :pointer], :enum
     attach_function :cuModuleLoadFatBinary, [:pointer, :pointer], :enum
     attach_function :cuModuleUnload, [:CUModule], :enum
+    class << self; alias_method :cuModuleGetGlobal, :cuModuleGetGlobal_v2; end
 
     # CU Execution Control.
     attach_function :cuFuncGetAttribute, [:pointer, CUFunctionAttribute, :CUFunction], :enum
@@ -580,33 +624,38 @@ module API
 
     # CU Stream Management.
     attach_function :cuStreamCreate, [:pointer, :uint], :enum
-    attach_function :cuStreamDestroy, [:CUStream], :enum
+    attach_function :cuStreamDestroy_v2, [:CUStream], :enum
     attach_function :cuStreamQuery, [:CUStream], :enum
     attach_function :cuStreamSynchronize, [:CUStream], :enum
     attach_function :cuStreamWaitEvent, [:CUStream, :CUEvent, :uint], :enum
+    class << self; alias_method :cuStreamDestroy, :cuStreamDestroy_v2; end
 
     # CU Event Management.
     attach_function :cuEventCreate, [:pointer, :uint], :enum
-    attach_function :cuEventDestroy, [:CUEvent], :enum
+    attach_function :cuEventDestroy_v2, [:CUEvent], :enum
     attach_function :cuEventElapsedTime, [:pointer, :CUEvent, :CUEvent], :enum
     attach_function :cuEventQuery, [:CUEvent], :enum
     attach_function :cuEventRecord, [:CUEvent, :CUStream], :enum
     attach_function :cuEventSynchronize, [:CUEvent], :enum
+    class << self; alias_method :cuEventDestroy, :cuEventDestroy_v2; end
 
     # CU Texture Reference Management.
-    attach_function :cuTexRefGetAddress, [:pointer, :CUTexRef], :enum
+    attach_function :cuTexRefGetAddress_v2, [:pointer, :CUTexRef], :enum
     attach_function :cuTexRefGetAddressMode, [:pointer, :CUTexRef, :int], :enum
     attach_function :cuTexRefGetArray, [:pointer, :CUTexRef], :enum
     attach_function :cuTexRefGetFilterMode, [:pointer, :CUTexRef], :enum
     attach_function :cuTexRefGetFlags, [:pointer, :CUTexRef], :enum
     attach_function :cuTexRefGetFormat, [:pointer, :pointer, :CUTexRef], :enum
-    attach_function :cuTexRefSetAddress, [:pointer, :CUTexRef, :CUDevicePtr, :size_t], :enum
-    attach_function :cuTexRefSetAddress2D, [:CUTexRef, :pointer, :CUDevicePtr, :size_t], :enum
+    attach_function :cuTexRefSetAddress_v2, [:pointer, :CUTexRef, :CUDevicePtr, :size_t], :enum
+    attach_function :cuTexRefSetAddress2D_v2, [:CUTexRef, :pointer, :CUDevicePtr, :size_t], :enum
     attach_function :cuTexRefSetAddressMode, [:CUTexRef, :int, CUAddressMode], :enum
     attach_function :cuTexRefSetArray, [:CUTexRef, :CUArray, :uint], :enum
     attach_function :cuTexRefSetFilterMode, [:CUTexRef, CUFilterMode], :enum
     attach_function :cuTexRefSetFlags, [:CUTexRef, :uint], :enum
     attach_function :cuTexRefSetFormat, [:CUTexRef, CUArrayFormat, :int], :enum
+    class << self; alias_method :cuTexRefGetAddress, :cuTexRefGetAddress_v2; end
+    class << self; alias_method :cuTexRefSetAddress, :cuTexRefSetAddress_v2; end
+    class << self; alias_method :cuTexRefSetAddress2D, :cuTexRefSetAddress2D_v2; end
     # Deprecated.
     attach_function :cuTexRefCreate, [:pointer], :enum
     attach_function :cuTexRefDestroy, [:CUTexRef], :enum

data/lib/cuda/driver/function.rb

@@ -49,7 +49,7 @@ class CUFunction
                     size = 4
                 when CUDevicePtr
                     p = FFI::MemoryPointer.new(:CUDevicePtr)
-                    API::write_cudeviceptr(p, x.to_api.address)
+                    API::write_cudeviceptr(p, x.to_api)
                     size = p.size
                 else
                     raise TypeError, "Invalid type of argument #{x.to_s}."
@@ -99,7 +99,9 @@ class CUFunction
     # @param [Integer] nbytes The size of the arbitrary data in bytes.
     # @return [CUFunction] This function.
     def param_setv(offset, ptr, nbytes)
-        status = API::cuParamSetv(self.to_api, offset, ptr.to_api, nbytes)
+        p = FFI::MemoryPointer.new(:pointer)
+        API::write_size_t(p, ptr.to_api.to_i) # Workaround broken p.write_pointer() on 64bit pointer.
+        status = API::cuParamSetv(self.to_api, offset, p, nbytes)
         Pvt::handle_error(status, "Failed to set function arbitrary parameter: offset = #{offset}, size = #{nbytes}.")
         self
     end
@@ -272,7 +274,7 @@ private
                     FFI::MemoryPointer.new(:float).write_float(x)
                 when CUDevicePtr
                     ptr = FFI::MemoryPointer.new(:CUDevicePtr)
-                    API::write_cudeviceptr(ptr, x.to_api.address)
+                    API::write_cudeviceptr(ptr, x.to_api)
                     ptr
                 else
                     raise TypeError, "Invalid type of kernel parameter #{x.to_s}."

data/lib/cuda/runtime/cuda.rb

@@ -22,8 +22,10 @@
 # along with SGC-Ruby-CUDA.  If not, see <http://www.gnu.org/licenses/>.
 #
 
+require 'delegate'
 require 'cuda/runtime/ffi-cuda'
 require 'memory/buffer'
+require 'helpers/struct'
 
 
 module SGC
@@ -37,7 +39,7 @@ module Cuda
     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 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
@@ -50,16 +52,27 @@ module Cuda
     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
+    class Dim3 < DelegateClass(API::Dim3); end # See {file:lib/cuda/runtime/ffi-cuda.rb}
+    class CudaDeviceProp < DelegateClass(API::CudaDeviceProp); end # See {file:lib/cuda/runtime/ffi-cuda.rb}
+    class CudaFunctionAttributes < DelegateClass(API::CudaFunctionAttributes); end # See {file:lib/cuda/runtime/ffi-cuda.rb}
+    class CudaChannelFormatDesc < DelegateClass(API::CudaChannelFormatDesc); end # See {file:lib/cuda/runtime/ffi-cuda.rb}
+    class CudaPitchedPtr < DelegateClass(API::CudaPitchedPtr); end # See {file:lib/cuda/runtime/ffi-cuda.rb}
+    class CudaPos < DelegateClass(API::CudaPos); end # See {file:lib/cuda/runtime/ffi-cuda.rb}
+    class CudaExtent < DelegateClass(API::CudaExtent); end # See {file:lib/cuda/runtime/ffi-cuda.rb}
+    class CudaMemcpy3DParms < DelegateClass(API::CudaMemcpy3DParms); end # See {file:lib/cuda/runtime/ffi-cuda.rb}
+    class TextureReference < DelegateClass(API::TextureReference); end # See {file:lib/cuda/runtime/ffi-cuda.rb}
+    class SurfaceReference < DelegateClass(API::SurfaceReference); end  # See {file:lib/cuda/runtime/ffi-cuda.rb}
+
+    SGC::Helper::Struct::Pvt::define_delegated_struct_methods(Dim3, API::Dim3)
+    SGC::Helper::Struct::Pvt::define_delegated_struct_methods(CudaDeviceProp, API::CudaDeviceProp)
+    SGC::Helper::Struct::Pvt::define_delegated_struct_methods(CudaFunctionAttributes, API::CudaFunctionAttributes)
+    SGC::Helper::Struct::Pvt::define_delegated_struct_methods(CudaChannelFormatDesc, API::CudaChannelFormatDesc)
+    SGC::Helper::Struct::Pvt::define_delegated_struct_methods(CudaPitchedPtr, API::CudaPitchedPtr)
+    SGC::Helper::Struct::Pvt::define_delegated_struct_methods(CudaPos, API::CudaPos)
+    SGC::Helper::Struct::Pvt::define_delegated_struct_methods(CudaExtent, API::CudaExtent)
+    SGC::Helper::Struct::Pvt::define_delegated_struct_methods(CudaMemcpy3DParms, API::CudaMemcpy3DParms)
+    SGC::Helper::Struct::Pvt::define_delegated_struct_methods(TextureReference, API::TextureReference)
+    SGC::Helper::Struct::Pvt::define_delegated_struct_methods(SurfaceReference, API::SurfaceReference)
 
 end # module
 end # module

data/lib/cuda/runtime/device.rb

@@ -72,7 +72,7 @@ class CudaDevice
 
 
     # @param [Integer] devid The index of the device to query.
-    # @return [CUDeviceProp] The properties of the device _devid_.
+    # @return [CudaDeviceProp] The properties of the device _devid_.
     def self.properties(devid = self.get)
         prop = CudaDeviceProp.new
         status = API::cudaGetDeviceProperties(prop.to_ptr, devid)
@@ -169,6 +169,44 @@ class CudaDevice
         self
     end
 
+
+    # @param [Integer] devid The device's ID which is to access the memory of the device _peer_devid_.
+    # @param [Integer] peer_devid The device's ID which its memory is to be accessed by the device _devid_.
+    # @return [Boolean] True if device _devid_ is capable of directly accessing memory from device _peer_devid_.
+    #
+    # @since CUDA 4.0
+    def self.can_access_peer?(devid = self.get, peer_devid)
+        b = FFI::MemoryPointer.new(:int)
+        status = API::cudaDeviceCanAccessPeer(b, devid, peer_devid)
+        Pvt::handle_error(status, "Failed to query can access peer: devid = #{devid}, peer_devid = #{peer_devid}.")
+        b.read_int == 1 ? true : false
+    end
+
+
+    # Enable the current device to access the memory of the peer device.
+    # @param [Integer] peer_devid The peer device's ID.
+    # @param [Integer] flags Currently flags must be set to zero.
+    # @return [Class] This class.
+    #
+    # @since CUDA 4.0
+    def self.enable_peer_access(peer_devid, flags = 0)
+        status = API::cudaDeviceEnablePeerAccess(peer_devid, flags)
+        Pvt::handle_error(status, "Failed to enable peer access: peer_devid = #{peer_devid}, flags = #{flags}.")
+        self
+    end
+
+
+    # Disable the current device from accessing the memory of the peer device.
+    # @param [Integer] peer_devid The peer device's ID.
+    # @return [Class] This class.
+    #
+    # @since CUDA 4.0
+    def self.disable_peer_access(peer_devid)
+        status = API::cudaDeviceDisablePeerAccess(peer_devid)
+        Pvt::handle_error(status, "Failed to disable peer access: peer_devid = #{peer_devid}.")
+        self
+    end
+
 end
 
 end # module

data/lib/cuda/runtime/ffi-cuda.rb

@@ -24,6 +24,7 @@
 
 require 'ffi'
 require 'ffi/prettystruct'
+require 'ffi/typedef'
 require 'helpers/interface/ienum'
 require 'helpers/flags'
 require 'helpers/klass'
@@ -230,9 +231,9 @@ module API
     def read_long(ptr); ptr.read_long; end
     def read_pointer(ptr); ptr.read_pointer; end
 
-    def write_int(ptr); ptr.write_int; end
-    def write_long(ptr); ptr.write_long; end
-    def write_pointer(ptr, value); ptr.write_pointer(value); end
+    def write_int(ptr, value); ptr.write_int(value); end
+    def write_long(ptr, value); ptr.write_long(value); end
+    def write_pointer(ptr, value); ptr.write_long(value.to_i); end
 
     alias read_size_t read_long
     alias read_enum read_int

data/lib/cuda/runtime/function.rb

@@ -81,7 +81,7 @@ class CudaFunction
     # @return [Class] This class.
     def self.configure(grid_dim, block_dim, shared_mem_size = 0, stream = 0)
         s = Pvt::parse_stream(stream)
-        status = API::cudaConfigureCall(grid_dim, block_dim, shared_mem_size, s)
+        status = API::cudaConfigureCall(grid_dim.to_api, block_dim.to_api, shared_mem_size, s)
         Pvt::handle_error(status, "Failed to configure kernel function launch settings.\n" +
             "* #{grid_dim.x} x #{grid_dim.y} x #{grid_dim.z} grid\n" +
             "* #{block_dim.x} x #{block_dim.y} x #{block_dim.z} blocks\n" +
@@ -105,7 +105,7 @@ class CudaFunction
                     size = 4
                 when SGC::Memory::MemoryPointer
                     p = x.ref
-                    size = FFI::MemoryPointer.size
+                    size = FFI::TypeDefs[:pointer].size
                 else
                     raise TypeError, "Invalid type of kernel parameters #{x}."
             end

data/lib/ffi/typedef.rb

@@ -0,0 +1,36 @@
+#
+# 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 'ffi'
+
+
+module FFI
+
+    unless defined?(self.typedef)
+        class << self
+            alias_method :typedef, :add_typedef
+        end
+    end
+
+end # module

data/lib/helpers/struct.rb

@@ -0,0 +1,51 @@
+#
+# 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
+
+module Struct
+
+    # @private
+    module Pvt
+
+        def self.define_delegated_struct_methods(klassA, klassD)
+            klassA.class_eval %{
+                def initialize(*args)
+                    @source = #{klassD.name}.new(*args)
+                    super(@source)
+                end
+
+                def to_api
+                    @source
+                end
+            }
+        end
+
+    end
+
+end
+
+end # module
+end # module

data/lib/memory/buffer.rb

@@ -91,7 +91,7 @@ class Buffer
 
     # @private
     def to_api
-        @ptr
+        @ptr.to_i
     end
 
 

data/lib/memory/pointer.rb

@@ -29,6 +29,7 @@ module SGC
 module Memory
 
 # A memory pointer class.
+# TODO: To use #write_pointer() when FFI fix the use of FIX2INT().
 class MemoryPointer
 
     # @param [Integer] addr Memory address _addr_ to initialize to.
@@ -49,8 +50,7 @@ class MemoryPointer
     # @param [Integer] addr Memory address to set to.
     # @return _addr_.
     def ptr=(addr)
-        @p.write_pointer(addr)
-        addr
+        @p.write_long(addr.to_i)
     end
 
 

data/test/rubycu/test_cucontext.rb

@@ -145,4 +145,28 @@ class TestCUContext < Test::Unit::TestCase
         assert_nil(s)
     end
 
+
+    def test_context_enable_disable_peer_access
+        current_dev = CUContext.device
+        count = CUDevice.count
+        (0...count).each do |devid|
+            dev = CUDevice.get(devid)
+            ctx = CUContext.create(dev)
+            if CUDevice.can_access_peer?(current_dev, dev)
+                assert_nothing_raised do
+                    CUContext.enable_peer_access(ctx)
+                    CUContext.disable_peer_access(ctx)
+                end
+            else
+                assert_raise(CUInvalidDeviceError) do
+                    CUContext.enable_peer_access(ctx)
+                end
+                assert_raise(CUPeerAccessNotEnabledError) do
+                    CUContext.disable_peer_access(ctx)
+                end
+            end
+            ctx.destroy
+        end
+    end
+
 end

data/test/rubycu/test_cudevice.rb

@@ -66,4 +66,15 @@ class TestCUDevice < Test::Unit::TestCase
         end
     end
 
+
+    def test_device_can_access_peer
+        current_dev = CUContext.device
+        count = CUDevice.count
+        (0...count).each do |devid|
+            dev = CUDevice.get(devid)
+            CUDevice.can_access_peer?(dev)
+            CUDevice.can_access_peer?(current_dev, dev)
+        end
+    end
+
 end

data/test/rubycu/test_cumemory.rb

@@ -82,7 +82,6 @@ class TestCUMemory < Test::Unit::TestCase
             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
@@ -96,7 +95,6 @@ class TestCUMemory < Test::Unit::TestCase
                 assert_equal(b[i], c[i])
             end
         end
-        end
 
         p.free
         q.free

data/test/rubycuda/test_cudadevice.rb

@@ -122,4 +122,35 @@ class TestCudaDevice < Test::Unit::TestCase
         assert_equal(CudaDevice, r)
     end
 
+
+    def test_device_can_access_peer
+        current_devid = CudaDevice.get
+        count = CudaDevice.count
+        (0...count).each do |devid|
+            CudaDevice.can_access_peer?(devid)
+            CudaDevice.can_access_peer?(current_devid, devid)
+        end
+    end
+
+
+    def test_device_enable_disable_peer_access
+        current_devid = CudaDevice.get
+        count = CudaDevice.count
+        (0...count).each do |devid|
+            if CudaDevice.can_access_peer?(devid)
+                assert_nothing_raised do
+                    CudaDevice.enable_peer_access(devid)
+                    CudaDevice.disable_peer_access(devid)
+                end
+            else
+                assert_raise(CudaInvalidDeviceError) do
+                    CudaDevice.enable_peer_access(devid)
+                end
+                assert_raise(CudaPeerAccessNotEnabledError) do
+                    CudaDevice.disable_peer_access(devid)
+                end
+            end
+        end
+    end
+
 end

data/test/rubycuda/testbase.rb

@@ -23,6 +23,7 @@
 #-----------------------------------------------------------------------
 
 require 'tempfile'
+require 'rbconfig'
 require 'rubycuda'
 
 include SGC::Cuda
@@ -50,7 +51,7 @@ module CudaTestBase
     end
 
     def nvcc_build_dynamic_library(src_path, lib_path)
-        case RUBY_PLATFORM
+        case Config::CONFIG['target_os']
             when /darwin/    # Build universal binary for i386 and x86_64 platforms.
                 f32 = Tempfile.new("rubycuda_test32.so")
                 f64 = Tempfile.new("rubycuda_test64.so")

data/version.rb

@@ -1 +1 @@
-SGC_RUBY_CUDA_VERSION = "0.1.0"
+SGC_RUBY_CUDA_VERSION = "0.1.1"

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 0
-  version: 0.1.0
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - Chung Shin Yee
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-30 00:00:00 +08:00
+date: 2011-05-08 00:00:00 +08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -82,9 +82,11 @@ files:
 - lib/cuda/runtime/thread.rb
 - lib/cuda/runtime/version.rb
 - lib/ffi/prettystruct.rb
+- lib/ffi/typedef.rb
 - lib/helpers/flags.rb
 - lib/helpers/interface/ienum.rb
 - lib/helpers/klass.rb
+- lib/helpers/struct.rb
 - lib/memory/buffer.rb
 - lib/memory/interface/ibuffer.rb
 - lib/memory/pointer.rb