cumo 0.4.3 → 0.5.0

data/lib/cumo/narray.rb

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 # This file is for compatibility with require 'numo/narray'
 require_relative '../cumo'

data/lib/cumo.rb

@@ -1,3 +1,5 @@
-require_relative File.join(__dir__, '../ext/cumo/cumo')
+# frozen_string_literal: true
+
+require_relative 'cumo.so'
 require_relative 'cumo/cuda'
 require_relative 'cumo/narray/extra'

data/test/bit_test.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class BitTest < Test::Unit::TestCase
+  dtype = Cumo::Bit
+
+  test dtype do
+    assert { dtype < Cumo::NArray }
+  end
+
+  procs = [
+    [proc { |tp, a| tp[*a] }, ""],
+    [proc { |tp, a| tp[*a][true] }, "[true]"],
+    [proc { |tp, a| tp[*a][0..-1] }, "[0..-1]"]
+  ]
+  procs.each do |init, ref|
+
+    test "#{dtype},[0,1,1,0,1,0,0,1]#{ref}" do
+      src = [0, 1, 1, 0, 1, 0, 0, 1]
+      n = src.size
+      a = init.call(dtype, src)
+
+      assert { a == src }
+      assert { (a & 0) == [0] * n }
+      assert { (a & 1) == src }
+      assert { (a | 0) == src }
+      assert { (a | 1) == [1] * n }
+      assert { (a ^ 0) == src.map { |x| x ^ 0 } }
+      assert { (a ^ 1) == src.map { |x| x ^ 1 } }
+      assert { ~a == src.map { |x| 1 - x } }
+
+      assert { a.count_true == 4 }
+      assert { a.count_false == 4 }
+      assert { a.where == [1, 2, 4, 7] }
+      assert { a.where2 == [[1, 2, 4, 7], [0, 3, 5, 6]] }
+      # TODO(sonots): FIX ME
+      # assert { a.mask(Cumo::DFloat[1,2,3,4,5,6,7,8]) == [2,3,5,8] }
+      assert { !a.all? }
+      assert { a.any? }
+      assert { !a.none? }
+    end
+  end
+
+  procs = [
+    [proc { |tp, a| tp[*a] }, ""],
+    [proc { |tp, a| tp[*a][true, 0..-1] }, "[true,true]"],
+  ]
+  procs.each do |init, ref|
+
+    test "#{dtype},[[0,1,1,0],[1,0,0,1]]#{ref}" do
+      src = [[0, 1, 1, 0], [1, 0, 0, 1]]
+      a = init.call(dtype, src)
+
+      assert { a[5] == 0 }
+      assert { a[-1] == 1 }
+      assert { a[1, 0] == src[1][0] }
+      assert { a[1, 1] == src[1][1] }
+      assert { a[1, 2] == src[1][2] }
+      assert { a[3..4] == [0, 1] }
+      assert { a[0, 1..2] == [1, 1] }
+      assert { a[0, :*] == src[0] }
+      assert { a[1, :*] == src[1] }
+      assert { a[:*, 1] == [src[0][1], src[1][1]] }
+
+      assert { a.count_true == 4 }
+      assert { a.count_false == 4 }
+      assert { a.where == [1, 2, 4, 7] }
+      assert { a.where2 == [[1, 2, 4, 7], [0, 3, 5, 6]] }
+      # TODO(sonots): FIX ME
+      # assert { a.mask(Cumo::DFloat[[1,2,3,4],[5,6,7,8]]) == [2,3,5,8] }
+      assert { !a.all? }
+      assert { a.any? }
+      assert { !a.none? }
+    end
+
+    test "#{dtype},[[0,1,1,0],[1,0,0,1]]#{ref},aset[]=" do
+      src = [[0, 1, 1, 0], [1, 0, 0, 1]]
+
+      a = init.call(dtype, src)
+      a[5] = 1
+      assert { a[5] == 1 }
+
+      a = init.call(dtype, src)
+      a[-1] = 0
+      assert { a[-1] == 0 }
+
+      a = init.call(dtype, src)
+      a[1, 0] = 0
+      assert { a[1, 0] == 0 }
+
+      a = init.call(dtype, src)
+      a[1, 1] = 1
+      assert { a[1, 1] == 1 }
+
+      a = init.call(dtype, src)
+      a[1, 2] = 1
+      assert { a[1, 2] == 1 }
+
+      a = init.call(dtype, src)
+      a[3..4] = [1, 0]
+      assert { a[3..4] == [1, 0] }
+
+      a = init.call(dtype, src)
+      a[0, 1..2] = [0, 0]
+      assert { a[0, 1..2] == [0, 0] }
+
+      a = init.call(dtype, src)
+      a[0, :*] = [1, 0, 0, 1]
+      assert { a[0, :*] == [1, 0, 0, 1] }
+
+      a = init.call(dtype, src)
+      a[1, :*] = [0, 1, 1, 0]
+      assert { a[1, :*] == [0, 1, 1, 0] }
+
+      a = init.call(dtype, src)
+      a[:*, 1] = [0, 1]
+      assert { a[:*, 1] == [0, 1] }
+
+      a = init.call(dtype, src)
+      a[5] = dtype.cast(1)
+      assert { a[5] == 1 }
+      assert { a[5] == dtype.cast(1) }
+
+      a = init.call(dtype, src)
+      a[1, 0] = dtype.cast(0)
+      assert { a[1, 0] == 0 }
+      assert { a[1, 0] == dtype.cast(0) }
+
+      a = init.call(dtype, src)
+      a[3..4] = dtype.cast([1, 0])
+      assert { a[3..4] == [1, 0] }
+      assert { a[3..4] == dtype.cast([1, 0]) }
+
+      a = init.call(dtype, src)
+      a[:*, 1] = dtype.cast([0, 1])
+      assert { a[:*, 1] == [0, 1] }
+      assert { a[:*, 1] == dtype.cast([0, 1]) }
+    end
+  end
+
+  test "store to view" do
+    n = 14
+    x = Cumo::Bit.zeros(n + 2, n + 2, 3)
+    ~(x[1..-2, 1..-2, 0].inplace)
+    assert { x.where.size == n * n }
+
+    x1 = Cumo::Bit.ones(n, n)
+    x0 = Cumo::Bit.zeros(n, n)
+    y0 = Cumo::Bit.zeros(n + 2, n + 2)
+    x = Cumo::NArray.dstack([x1, x0, x0])
+    y = Cumo::NArray.dstack([y0, y0, y0])
+    y[1..-2, 1..-2, true] = x
+    assert { (~y[1..-2, 1..-2, 0]).where.size == 0 }
+    assert { y[true, true, 1].where.size == 0 }
+  end
+end

data/test/cuda/compiler_test.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+module Cumo::CUDA
+  class CompilerTest < Test::Unit::TestCase
+    sub_test_case "valid_kernel_name?" do
+      def test_valid
+        assert_true(Compiler.valid_kernel_name?('valid_name_1'))
+      end
+
+      def test_empty
+        assert_false(Compiler.valid_kernel_name?(''))
+      end
+
+      def test_start_with_digit
+        assert_false(Compiler.valid_kernel_name?('0_invalid'))
+      end
+
+      def test_new_line
+        assert_false(Compiler.valid_kernel_name?("invalid\nname"))
+      end
+
+      def test_symbol
+        assert_false(Compiler.valid_kernel_name?("invalid$name"))
+      end
+
+      def test_space
+        assert_false(Compiler.valid_kernel_name?("invalid name"))
+      end
+    end
+
+    sub_test_case "compile_using_nvrtc" do
+      def test_valid
+        compiler = Compiler.new
+        source = "__global__ void k() {}\n"
+        ptx = compiler.compile_using_nvrtc(source)
+        assert { ptx =~ /Generated by NVIDIA NVVM Compiler/ }
+      end
+
+      def test_invalid
+        compiler = Compiler.new
+        source = "__global__ void k() {something_wrong}\n"
+        assert_raise(CompileError) { compiler.compile_using_nvrtc(source) }
+      end
+    end
+
+    sub_test_case "compile_with_cache" do
+      CACHE_DIR = File.join(__dir__, '.kernel_cache')
+
+      class << self
+        def startup
+          FileUtils.rm_rf(CACHE_DIR)
+        end
+      end
+
+      def test_valid
+        compiler = Compiler.new
+        source = "__global__ void k() {}\n"
+        assert_nothing_raised { compiler.compile_with_cache(source, cache_dir: CACHE_DIR) }
+      end
+
+      def test_valid_from_cache
+        test_valid
+        test_valid
+      end
+    end
+  end
+end

data/test/cuda/device_test.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+module Cumo::CUDA
+  class DeviceTest < Test::Unit::TestCase
+    def test_initialize
+      assert { Device.new(0).id == 0 }
+      assert { Device.new.id.is_a?(Integer) }
+    end
+
+    def test_use
+      assert_nothing_raised { Device.new(0).use }
+    end
+
+    def test_with
+      Device.new(0).with do
+        assert { Device.new.id == 0 }
+      end
+    end
+
+    def test_synchronize
+      assert_nothing_raised { Device.new.synchronize }
+    end
+
+    def test_compute_capability
+      assert { Device.new.compute_capability.size == 2 }
+    end
+  end
+end

data/test/cuda/memory_pool_test.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+module Cumo::CUDA
+  class MemoryPoolTest < Test::Unit::TestCase
+    def setup
+      @orig_state = MemoryPool.enabled?
+    end
+
+    def teardown
+      @orig_state ? MemoryPool.enable : MemoryPool.disable
+    end
+
+    def test_enable
+      MemoryPool.enable
+      assert { MemoryPool.enabled? }
+    end
+
+    def test_disable
+      MemoryPool.disable
+      assert { !MemoryPool.enabled? }
+    end
+
+    def test_free_all_blocks
+      assert_nothing_raised { MemoryPool.free_all_blocks }
+    end
+
+    def test_n_free_blocks
+      assert_nothing_raised { MemoryPool.n_free_blocks }
+    end
+
+    def test_used_bytes
+      assert_nothing_raised { MemoryPool.used_bytes }
+    end
+
+    def test_free_bytes
+      assert_nothing_raised { MemoryPool.free_bytes }
+    end
+
+    def test_total_bytes
+      assert_nothing_raised { MemoryPool.total_bytes }
+    end
+  end
+end

data/test/cuda/nvrtc_test.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+module Cumo::CUDA
+  class NVRTCTest < Test::Unit::TestCase
+    def test_nvrtcVersion
+      major, minor = NVRTC.nvrtcVersion
+      assert { major.is_a?(Integer) }
+      assert { minor.is_a?(Integer) }
+    end
+
+    def test_nvrtcCreateProgram
+      src = "__global__ void k() {}\n"
+      name = "simple.cu"
+      headers = []
+      include_names = []
+      assert_nothing_raised do
+        NVRTC.nvrtcCreateProgram(src, name, headers, include_names)
+      end
+    end
+
+    def test_nvrtcDestroyProgram
+      prog = test_nvrtcCreateProgram
+      assert_nothing_raised do
+        NVRTC.nvrtcDestroyProgram(prog)
+      end
+    end
+
+    def test_nvrtcCompileProgram
+      prog = test_nvrtcCreateProgram
+      options = []
+      assert_nothing_raised do
+        NVRTC.nvrtcCompileProgram(prog, options)
+      end
+      prog
+    end
+
+    def test_nvrtcGetPTX
+      prog = test_nvrtcCompileProgram
+      ptx = NVRTC.nvrtcGetPTX(prog)
+      assert { ptx =~ /Generated by NVIDIA NVVM Compiler/ }
+    end
+
+    def test_nvrtcGetProgramLog
+      prog = test_nvrtcCompileProgram
+      log = NVRTC.nvrtcGetProgramLog(prog)
+      assert { log.is_a?(String) }
+    end
+  end
+end

data/test/cuda/runtime_test.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+module Cumo::CUDA
+  class RuntimeTest < Test::Unit::TestCase
+    def test_cudaDriverGetVersion
+      assert { Runtime.cudaDriverGetVersion.is_a?(Integer) }
+    end
+
+    def test_cudaRuntimeGetVersion
+      assert { Runtime.cudaRuntimeGetVersion.is_a?(Integer) }
+    end
+
+    def test_cudaSetDevice_cudaGetDevice
+      assert_nothing_raised { Runtime.cudaSetDevice(0) }
+      assert { Runtime.cudaGetDevice == 0 }
+    end
+
+    def test_cudaGetDeviceCount
+      assert { Runtime.cudaGetDeviceCount.is_a?(Integer) }
+    end
+
+    def test_cudaDeviceSynchronize
+      assert_nothing_raised { Runtime.cudaDeviceSynchronize }
+    end
+  end
+end