CooCoo 0.1.0

data/lib/coo-coo/cuda/device_buffer/ffi.rb

@@ -0,0 +1,109 @@
+require 'ffi'
+require 'coo-coo/cuda/device_buffer'
+
+module CooCoo
+  module CUDA
+    class DeviceBuffer < ::FFI::Struct
+      module FFI
+        extend ::FFI::Library
+        ffi_lib Pathname.new(__FILE__).join('..', '..', '..', '..', '..', 'ext', 'buffer', "buffer.#{RbConfig::CONFIG['DLEXT']}").to_s
+
+        def self.buffer_function(*args)
+          if args.size == 3
+            func, args, return_type = args
+            meth = func
+          elsif args.size == 4
+            meth, func, args, return_type = args
+          else
+            raise ArgumentError.new("Wrong number of arguments: (given #{args.size}, expected 3 or 4")
+          end
+
+          attach_function("buffer_#{func}", args, return_type)
+
+          caller = if return_type.kind_of?(Symbol)
+                     :call_func
+                   else
+                     :call_buffer
+                   end
+          
+          class_eval <<-EOT
+            def self.#{meth}(*call_args)
+              #{caller}(:#{func}, *call_args)
+            end
+          EOT
+        end
+        
+        buffer_function :block_size, [], :int
+        buffer_function :set_block_size, [ :int ], :void
+        buffer_function :max_grid_size, [], :int
+        buffer_function :set_max_grid_size, [ :int ], :void
+
+        buffer_function :init, [ :int ], :int
+        buffer_function :total_bytes_allocated, [], :size_t
+        buffer_function :num_allocated, [], :long_long
+
+        buffer_function :new, [ :size_t, :double ], DeviceBuffer.auto_ptr
+        buffer_function :free, [ DeviceBuffer ], :size_t
+        buffer_function :length, [ DeviceBuffer ], :size_t
+        buffer_function :set, [ DeviceBuffer, DeviceBuffer ], :int
+        buffer_function :setv, [ DeviceBuffer, :pointer, :size_t ], :int
+        buffer_function :setvn, [ DeviceBuffer, :size_t, :pointer, :size_t ], :int
+        buffer_function :setd, [ DeviceBuffer, :double, :size_t, :size_t ], :int
+        buffer_function :set_element, [ DeviceBuffer, :size_t, :double ], :int
+        buffer_function :get, [ DeviceBuffer, :pointer, :size_t ], :int
+        buffer_function :slice, [ DeviceBuffer, :size_t, :size_t ], DeviceBuffer.auto_ptr
+        buffer_function :slice_2d, [ DeviceBuffer, :size_t, :size_t, :size_t, :size_t, :size_t, :size_t, :double ], DeviceBuffer.auto_ptr
+        buffer_function :set2d, [ DeviceBuffer, :size_t, DeviceBuffer, :size_t, :size_t, :size_t ], :int
+        buffer_function :set2dv, [ DeviceBuffer, :size_t, :pointer, :size_t, :size_t, :size_t, :size_t ], :int
+        buffer_function :host_slice, [ DeviceBuffer, :pointer, :size_t, :size_t ], :int
+
+        [ :add, :sub, :mul, :pow, :div,
+          :collect_eq, :collect_neq, :collect_lt, :collect_lte, :collect_gt, :collect_gte
+        ].each do |binary_op|
+          buffer_function binary_op, [ DeviceBuffer, DeviceBuffer ], DeviceBuffer.auto_ptr
+          buffer_function "#{binary_op}d", [ DeviceBuffer, :double ], DeviceBuffer.auto_ptr
+        end
+        buffer_function :eq, [ DeviceBuffer, DeviceBuffer ], :int
+        buffer_function :addd, [ DeviceBuffer, :double ], DeviceBuffer.auto_ptr
+        buffer_function :subd, [ DeviceBuffer, :double ], DeviceBuffer.auto_ptr
+        buffer_function :muld, [ DeviceBuffer, :double ], DeviceBuffer.auto_ptr
+        buffer_function :divd, [ DeviceBuffer, :double ], DeviceBuffer.auto_ptr
+
+        buffer_function :sum, [ DeviceBuffer ], :double
+        buffer_function :min, [ DeviceBuffer ], :double
+        buffer_function :max, [ DeviceBuffer ], :double
+          
+        buffer_function :dot, [ DeviceBuffer, :size_t, :size_t, DeviceBuffer, :size_t, :size_t ], DeviceBuffer.auto_ptr
+        buffer_function :identity, [ :size_t, :size_t ], DeviceBuffer.auto_ptr
+        buffer_function :diagflat, [ DeviceBuffer ], DeviceBuffer.auto_ptr
+
+        [ :abs, :exp, :log, :log10, :log2, :sqrt,
+          :sin, :asin, :cos, :acos, :tan, :atan,
+          :sinh, :asinh, :cosh, :acosh, :tanh, :atanh,
+          :ceil, :floor, :round,
+          :collect_nan, :collect_inf
+        ].each do |f|
+          buffer_function f, [ DeviceBuffer ], DeviceBuffer.auto_ptr
+        end
+
+        def self.call_func(func, *args)
+          r = send("buffer_#{func}", *args)
+          raise APIError.new(r) if r != 0
+          r
+        end
+        
+        def self.call_buffer(func, *args)
+          retries = 0
+          r = send("buffer_#{func}", *args)
+          raise NullResultError.new if r.null?
+          r
+        rescue NullResultError
+          raise if retries > 1
+          retries += 1
+          CUDA.collect_garbage
+          retry
+        end
+      end
+    end
+  end
+end

data/lib/coo-coo/cuda/error.rb

@@ -0,0 +1,51 @@
+require 'coo-coo/cuda/runtime'
+
+module CooCoo
+  module CUDA
+    class Error < RuntimeError
+    end
+
+    class APIError < Error
+      def initialize(err = nil)
+        @err = err || Runtime.cudaGetLastError()
+        super(message)
+      end
+
+      def message
+        "CUDA API Error: #{name} #{string}"
+      end
+
+      def error
+        @err
+      end
+      
+      def name
+        Runtime.cudaGetErrorName(@err)
+      end
+
+      def string
+        Runtime.cudaGetErrorString(@err)
+      end
+    end
+
+    class NoMemoryError < Error
+      def initialize(amount = nil)
+        if amount
+          super("CUDA failed to allocate #{amount} bytes on the device.")
+        else
+          super("CUDA failed to allocate memory on the device.")
+        end
+      end
+    end
+
+    class NullResultError < Error
+      def initialize(msg = "NULL CUDA result")
+        @cuda_error = APIError.new
+        super(msg + ": Last #{@cuda_error.message}")
+      end
+
+      attr_reader :cuda_error
+    end
+
+  end
+end

data/lib/coo-coo/cuda/host_buffer.rb

@@ -0,0 +1,117 @@
+require 'ffi'
+
+module CooCoo
+  module CUDA
+    TYPE_GETTER = {
+      char: :read_char,
+      long: :read_long,
+      float: :read_float,
+      double: :read_double
+    }
+    TYPE_WRITER = {
+      char: :write_char,
+      long: :write_long,
+      float: :write_float,
+      double: :write_double
+    }
+    TYPE_CONVERTOR = {
+      double: ->(x) { x.to_f },
+      float: ->(x) { x.to_f },
+      long: ->(x) { x.to_i },
+      char: ->(x) { x.to_i }
+    }
+    
+    class HostBuffer
+      attr_reader :size, :type
+
+      def self.[](other, length = nil)
+        if other.kind_of?(self)
+          return other.resize(length || other.size)
+        elsif other.respond_to?(:each_with_index)
+          return self.new(length || other.size).set(other)
+        elsif other.kind_of?(Numeric)
+          return self.new(length || 1).set(other)
+        else
+          return self[other.to_enum, length]
+        end
+      end
+      
+      def initialize(size, type = :double)
+        @size = size
+        @type = type
+        @buffer = ::FFI::MemoryPointer.new(type, size)
+      end
+
+      def resize(new_size)
+        return self if @size == new_size
+
+        self.class.new(new_size).set(self.each)
+      end
+
+      def byte_size
+        @size * type_size
+      end
+      
+      def type_size
+        ::FFI.type_size(@type)
+      end
+
+      def set(values)
+        if values.respond_to?(:each_with_index)
+          values.each_with_index do |v, i|
+            break if i >= size
+            self[i] = v
+          end
+        else
+          size.times do |i|
+            self[i] = values
+          end
+        end
+
+        self
+      end
+
+      def get
+        @buffer
+      end
+
+      def to_ptr
+        @buffer
+      end
+
+      def []=(index, value)
+        @buffer[index].send(type_writer, type_convertor.call(value))
+      end
+      
+      def [](index)
+        @buffer[index].send(type_reader)
+      end
+
+      def each(&block)
+        return to_enum(__method__) unless block_given?
+
+        size.times do |i|
+          block.call(self[i])
+        end
+      end
+
+      def type_writer
+        @type_writer ||= TYPE_WRITER[@type]
+      end
+
+      def type_convertor
+        @type_convertor ||= TYPE_CONVERTOR[@type]
+      end
+      
+      def type_reader
+        @type_reader ||= TYPE_GETTER[@type]
+      end
+      
+      def to_a
+        @size.times.collect do |i|
+          self[i]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,157 @@
+require 'ffi'
+require 'coo-coo/platform'
+
+module CooCoo
+  module CUDA
+    module Runtime
+      extend ::FFI::Library
+      if CooCoo::Platform.windows?
+        ffi_lib 'cudart64_90.dll'
+      else
+        ffi_lib 'libcudart.so'
+      end
+
+      class DeviceProperties < ::FFI::Struct
+        layout(:name, [ :char, 256 ],
+               :totalGlobalMem, :size_t,
+               :sharedMemPerBlock, :size_t,
+               :regsPerBlock, :int,
+               :warpSize, :int,
+               :memPitch, :size_t,
+               :maxThreadsPerBlock, :int,
+               :maxThreadsDim, [ :int, 3 ],
+               :maxGridSize, [ :int, 3 ],
+               :clockRate, :int,
+               :totalConstMem, :size_t,
+               :major, :int,
+               :minor, :int,
+               :textureAlignment, :size_t,
+               :texturePitchAlignment, :size_t,
+               :deviceOverlap, :int,
+               :multiProcessorCount, :int,
+               :kernelExecTimeoutEnabled, :int,
+               :integrated, :int,
+               :canMapHostMemory, :int,
+               :computeMode, :int,
+               :maxTexture1D, :int,
+               :maxTexture1DMipmap, :int,
+               :maxTexture1DLinear, :int,
+               :maxTexture2D, [ :int, 2 ],
+               :maxTexture2DMipmap, [ :int, 2 ],
+               :maxTexture2DLinear, [ :int, 3 ],
+               :maxTexture2DGather, [ :int, 2 ],
+               :maxTexture3D, [ :int, 3 ],
+               :maxTexture3DAlt, [ :int, 3 ],
+               :maxTextureCubemap, :int,
+               :maxTexture1DLayered, [ :int, 2 ],
+               :maxTexture2DLayered, [ :int, 3 ],
+               :maxTextureCubemapLayered, [ :int, 2 ],
+               :maxSurface1D, :int,
+               :maxSurface2D, [ :int, 2 ],
+               :maxSurface3D, [ :int, 3 ],
+               :maxSurface1DLayered, [ :int, 2 ],
+               :maxSurface2DLayered, [ :int, 3 ],
+               :maxSurfaceCubemap, :int,
+               :maxSurfaceCubemapLayered, [ :int, 2 ],
+               :surfaceAlignment, :size_t,
+               :concurrentKernels, :int,
+               :ecc_enabled, :int,
+               :pciBusID, :int,
+               :pciDeviceID, :int,
+               :pciDomainID, :int,
+               :tccDriver, :int,
+               :asyncEngineCount, :int,
+               :unifiedAddressing, :int,
+               :memoryClockRate, :int,
+               :memoryBusWidth, :int,
+               :l2CacheSize, :int,
+               :maxThreadsPerMultiProcessor, :int,
+               :streamPrioritiesSupported, :int,
+               :globalL1CacheSupported, :int,
+               :localL1CacheSupported, :int,
+               :sharedMemPerMultiprocessor, :size_t,
+               :regsPerMultiprocessor, :int,
+               :managedMemSupported, :int,
+               :isMultiGpuBoard, :int,
+               :multiGpuBoardGroupID, :int,
+               :singleToDoublePrecisionPerfRatio, :int,
+               :pageableMemoryAccess, :int,
+               :concurrentManagedAccess, :int,
+               :computePreemptionSupported, :int,
+               :canUseHostPointerForRegisteredMem, :int,
+               :cooperativeLaunch, :int,
+               :cooperativeMultiDeviceLaunch, :int
+               )
+      end
+      attach_function :cudaGetErrorName, [ :int ], :string
+      attach_function :cudaGetErrorString, [ :int ], :string
+      attach_function :cudaGetLastError, [], :int
+
+      attach_function :cudaDeviceReset, [], :int
+      attach_function :cudaSetDevice, [ :int ], :int
+      attach_function :cudaGetDevice, [ :pointer ], :int
+      attach_function :cudaGetDeviceCount, [ :pointer ], :int
+      attach_function :cudaGetDeviceFlags, [ :pointer ], :int
+      attach_function :cudaGetDeviceProperties, [ DeviceProperties, :int ], :int
+
+      attach_function :cudaMemGetInfo, [ :pointer, :pointer ], :int
+
+      attach_function :cudaMalloc, [ :pointer, :int ], :void
+      attach_function :cudaFree, [ :pointer ], :void
+
+      enum :memcpy_modes, [ :host_to_device, 1, :device_to_host, 2 ]
+      attach_function :cudaMemcpy, [ :pointer, :pointer, :int, :memcpy_modes ], :void
+
+      def self.get_device
+        dev = ::FFI::MemoryPointer.new(:int, 1)
+        cudaGetDevice(dev)
+        dev.read_int
+      end
+
+      def self.set_device(dev)
+        err = cudaSetDevice(dev)
+        raise APIError.new(err) if err != 0
+        dev
+      end
+      
+      def self.device_count
+        n = ::FFI::MemoryPointer.new(:int, 1)
+        cudaGetDeviceCount(n)
+        n.read_int
+      end
+
+      def self.get_device_props(dev = nil)
+        props = DeviceProperties.new
+        cudaGetDeviceProperties(props, dev || get_device)
+        props
+      end
+
+      def self.read_size_t(pointer)
+        if @size_t_reader == nil
+          type = ::FFI.find_type(:size_t)
+          @size_t_reader = case type.size
+                           when 8 then :read_ulong_long
+                           when 4 then :read_ulong
+                           when 2 then :read_ushort
+                           when 1 then :read_ubyte
+                           else raise ArgumentError.new("size_t type not found")
+                           end
+        end
+
+        pointer.send(@size_t_reader)
+      end
+      
+      def self.memory_info
+        free = ::FFI::MemoryPointer.new(:size_t, 1)
+        total = ::FFI::MemoryPointer.new(:size_t, 1)
+        err = cudaMemGetInfo(free, total)
+        raise APIError.new(err) if err != 0
+        [ read_size_t(free), read_size_t(total) ]
+      end
+      
+      def self.total_global_mem
+        memory_info[1]
+      end
+    end
+  end
+end

data/lib/coo-coo/cuda/vector.rb

@@ -0,0 +1,315 @@
+require 'coo-coo/math/abstract_vector'
+require 'coo-coo/cuda/device_buffer'
+require 'coo-coo/core_ext'
+
+module CooCoo
+  module CUDA
+    class Vector < CooCoo::Math::AbstractVector
+      def initialize(length, initial_value = 0.0, &block)
+        if length != nil && length <= 0
+          raise ArgumentError.new("Invalid Vector size")
+        elsif length != nil
+          @elements = DeviceBuffer.create(length, initial_value)
+          if block
+            @elements.size.times.each_slice(1024).with_index do |slice, slice_idx|
+              @elements[slice_idx * 1024, 1024] = slice.collect do |i|
+                block.call(i)
+              end
+            end
+          end
+        end
+      end
+
+      def self.[](value, max_size = nil, default_value = 0.0)
+        if value.kind_of?(DeviceBuffer)
+          v = new(nil)
+          v.instance_variable_set('@elements', value)
+          v
+        else
+          if value.respond_to?(:each)
+            max_size ||= value.size
+          else
+            max_size ||= 1
+          end
+          new(max_size, default_value).set(value)
+        end
+      end
+
+      def set(values)
+        if values.kind_of?(self.class)
+          @elements.set(values.elements)
+        else
+          @elements.set(values)
+        end
+        
+        self
+      end
+
+      def self.zeros(length)
+        self.new(length, 0.0)
+      end
+
+      def self.ones(length)
+        self.new(length, 1.0)
+      end
+
+      def zeros
+        self.zeros(size)
+      end
+
+      def self.identity(w, h)
+        self[DeviceBuffer.identity(w, h)]
+      end
+
+      def diagflat
+        self.class[@elements.diagflat]
+      end
+
+      def clone
+        self.class.new(self.size).set(@elements)
+      end
+
+      def append(other)
+        b = self.class.new(size + other.size)
+        b[0, size] = self
+        b[size, other.size] = other
+        b
+      end
+      
+      def coerce(other)
+        if other.respond_to?(:each)
+          return self.class[other], self
+        else
+          return self.class.new(self.size, other), self
+        end
+      end
+
+      def to_s
+        '[' + each.collect(&:to_f).join(', ') + ']'
+      end
+      
+      def inspect
+        to_a.inspect
+      end
+      
+      def to_a
+        @elements.to_a
+      end
+
+      def _dump(depth)
+        @elements.to_a.pack('E*')
+      end
+
+      def self._load(args)
+        arr = args.unpack('E*')
+        self[arr]
+      end
+
+      def null?
+        @elements.null?
+      end
+
+      def [](i, len = nil)
+        v = @elements[i, len]
+        if len
+          self.class[v]
+        else
+          v
+        end
+      end
+
+      def []=(i, v, l = nil)
+        if l == nil
+          @elements[i] = v
+        else
+          @elements[i, v] = l
+        end
+      end
+
+      def each(&block)
+        @elements.each(&block)
+      end
+
+      def each_with_index(&block)
+        @elements.each.with_index(&block)
+      end
+
+      def each_slice(n, &block)
+        return to_enum(__method__, n) unless block
+        
+        @elements.each_slice(n) do |slice|
+          block.call(self.class[slice])
+        end
+      end
+
+      # @!method min
+      #   @return [Float] minimum value of +self+
+      # @!method max
+      #   @return [Float] maximum value of +self+
+      # @!method minmax
+      #   @return [[Float, Float]] {#min} and {#max} values of +self+
+      # @!method sum
+      #   Reduces the vector with {#+}.
+      #   @return [Float] the sum of +self+
+      delegate :min, :max, :minmax, :sum, :to => :elements
+
+      def sum
+        @elements.sum
+      end
+
+      def average
+        @elements.sum / size
+      end
+
+      def magnitude_squared
+        (self * self).sum
+      end
+
+      def magnitude
+        ::Math.sqrt(magnitude_squared)
+      end
+      
+      def normalize
+        self / magnitude
+      end
+
+      def dot(w, h, other, ow = nil, oh = nil)
+        if other.kind_of?(self.class)
+          self.class[@elements.dot(w, h, other.elements, ow, oh)]
+        elsif other.respond_to?(:each)
+          dot(w, h, self.class[other.each], ow, oh)
+        else
+          raise ArgumentError.new("argument is not a #{self.class} or Enumerator")
+        end
+      end
+
+      private
+      def self.bin_op(op)
+        class_eval <<-EOT
+        def #{op}(other)
+          if other.kind_of?(self.class)
+            self.class[@elements.send(:#{op}, other.elements)]
+          else
+            self.class[@elements.send(:#{op}, other)]
+          end
+        end
+EOT
+      end
+
+      public
+      # @!macro [attach] vector.bin_op
+      #   @!method $1(other)
+      #     Calls the equivalent of +#$1+ on each element of +self+ against +other+.
+      #     @param other [Vector, Array, Enumerable, Numeric]
+      #     @return [Vector]
+      bin_op('<')
+      bin_op('<=')
+      bin_op('>=')
+      bin_op('>')
+      bin_op('+')
+      bin_op('-')
+      bin_op('*')
+      bin_op('/')
+      bin_op('**')
+      bin_op('collect_equal?')
+      bin_op('collect_not_equal?')
+
+      # Negates every element in the vector.
+      # @return [Vector]
+      def -@
+        self * -1.0
+      end
+
+      def collect_equal?(n)
+        if n.kind_of?(self.class)
+          self.class[@elements.collect_equal?(n.elements)]
+        else
+          self.class[@elements.collect_equal?(n)]
+        end
+      end
+      
+      def size
+        @elements.size
+      end
+      
+      def length
+        @elements.size
+      end
+      
+      def ==(other)
+        if other.kind_of?(self.class)
+          @elements == other.elements
+        elsif other != nil
+          b, a = coerce(other)
+          self == b
+        else
+          false
+        end
+      end
+
+      private
+      def self.f(name, real_name = nil)
+        class_eval <<-EOT
+        def #{name}
+          self.class[@elements.send(:#{real_name || name})]
+        end
+EOT
+      end
+
+      public
+      
+      # @!macro [attach] vector.f
+      #   @!method $1()
+      #     Calls the equivalent of +Math.$1+ on each element of +self+.
+      #     @return [Vector] the equivalent of +Math.$1+ over +self+.
+      f :abs
+      f :exp
+      f :log
+      f :log10
+      f :log2
+      f :sqrt
+      f :sin
+      f :asin
+      f :cos
+      f :acos
+      f :tan
+      f :atan
+      f :sinh
+      f :asinh
+      f :cosh
+      f :acosh
+      f :tanh
+      f :atanh
+      f :ceil
+      f :floor
+      f :round
+      f :collect_nan?, :collect_nan
+      f :collect_infinite?, :collect_inf
+
+      def nan?
+        collect_nan?.sum > 0
+      end
+
+      def infinite?
+        collect_infinite?.sum > 0
+      end
+
+      def slice_2d(*args)
+        self.class[@elements.slice_2d(*args)]
+      end
+
+      def set2d!(width, src, src_width, x, y)
+        raise ArgumentError.new("src's size #{src.size} must be divisible by src_width #{src_width}") if src.respond_to?(:each) && src.size % src_width > 0
+        
+        src = src.elements if src.kind_of?(self.class)
+        @elements.set2d!(width, src, src_width, x, y)
+        self
+      end
+
+      protected
+      def elements
+        @elements
+      end
+    end
+  end
+end