cumo 0.4.3 → 0.5.0

data/3rd_party/mkmf-cu/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source "http://rubygems.org"
 
 gemspec

data/3rd_party/mkmf-cu/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'bundler/gem_tasks'
 require 'rake/testtask'
 require 'rake/clean'
@@ -8,4 +10,3 @@ end
 desc "Run tests"
 
 task :default => [:test]
-

data/3rd_party/mkmf-cu/bin/mkmf-cu-nvcc

@@ -1,4 +1,6 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
+
 require_relative "../lib/mkmf-cu/cli"
 
 MakeMakefileCuda::CLI.new(ARGV).run

data/3rd_party/mkmf-cu/lib/mkmf-cu/cli.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "open3"
 require_relative "nvcc"
 
@@ -6,7 +8,7 @@ module MakeMakefileCuda
     attr_reader :argv
 
     def initialize(argv)
-      @argv = argv.map{|e| e.dup }
+      @argv = argv.map { |e| e.dup }
     end
 
     def run
@@ -32,17 +34,35 @@ module MakeMakefileCuda
     # TODO(sonots): Make it possible to configure "nvcc" and additional arguments
     def nvcc_command
       s = MakeMakefileCuda::Nvcc.generate(argv)
-      cmd = "nvcc " << s
+      cmd = "nvcc #{s}"
       if ENV['CUMO_NVCC_GENERATE_CODE']
         cmd << " --generate-code=#{ENV['CUMO_NVCC_GENERATE_CODE']}"
       elsif ENV['DEBUG']
         cmd << " -arch=sm_35"
       else
-        cmd << " --generate-code=arch=compute_35,code=sm_35"
-        cmd << " --generate-code=arch=compute_50,code=sm_50"
-        cmd << " --generate-code=arch=compute_60,code=sm_60"
-        cmd << " --generate-code=arch=compute_70,code=sm_70"
-        cmd << " --generate-code=arch=compute_70,code=compute_70"
+        # Ref. https://en.wikipedia.org/wiki/CUDA
+        if cuda_version >= Gem::Version.new("13.0")
+          # CUDA 13.0
+          capability = [75, 87, 89, 90, 121]
+        elsif cuda_version >= Gem::Version.new("12.9")
+          # CUDA 12.9
+          capability = [50, 60, 70, 75, 87, 89, 90, 121]
+        elsif cuda_version >= Gem::Version.new("12.8")
+          # CUDA 12.8
+          capability = [50, 60, 70, 75, 87, 89, 90, 120]
+        elsif cuda_version >= Gem::Version.new("12.0")
+          # CUDA 12.0 – 12.6
+          capability = [50, 60, 70, 75, 87, 89, 90]
+        elsif cuda_version >= Gem::Version.new("11.8")
+          # CUDA 11.8
+          capability = [35, 50, 60, 70, 75, 87, 89, 90]
+        else
+          # CUDA 11.0
+          capability = [35, 50, 60, 70, 75, 80]
+        end
+        capability.each do |arch|
+          cmd << " --generate-code=arch=compute_#{arch},code=sm_#{arch}"
+        end
       end
       cmd
     end
@@ -88,5 +108,14 @@ module MakeMakefileCuda
       raise "#{color_code} is not supported" unless COLOR_CODES[code]
       "\e[#{COLOR_CODES[code]}m#{str}\e[0m"
     end
+
+    def cuda_version
+      @cuda_version ||= begin
+        output = `nvcc --version`
+        if output =~ /Cuda compilation tools, release ([^,]*),/
+          Gem::Version.new($1)
+        end
+      end
+    end
   end
 end

data/3rd_party/mkmf-cu/lib/mkmf-cu/nvcc.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "optparse"
 require "rbconfig"
 
@@ -29,50 +31,50 @@ module MakeMakefileCuda
 
     def build_optparser
       opt = OptionParser.new
-      opt_h = Hash.new{|h, k| h[k] = [] }
-
-      opt.on("--arch arg") {|v| opt_h["-arch"] << v }
-      opt.on("--std arg") {|v| opt_h["-std"] << v }
-      opt.on("--stdlib arg") {|v| opt_h["-stdlib"] << v }
-
-      opt.on("--Wl arg") {|v| opt_h["-Wl"] << v }
-
-      opt.on('--profile') {|v| opt_h["-pg"] << "" }
-      opt.on('-g') {|v| opt_h["-g"] << "" }
-      opt.on('-G', "--device-debug") {|v| opt_h["-G"] << "" }
-
-      opt.on('-I path') {|v| opt_h["-I"] << v }
-      opt.on('-D flag') {|v| opt_h["-D"] << v }
-      opt.on('-W flag') {|v| opt_h["-W"] << v }
-      opt.on('-o output') {|v| opt_h["-o"] << v }
-      opt.on('-c file') {|v| opt_h["-c"] << v }
-      opt.on('-f flag') {|v| opt_h["-f"] << v }
-      opt.on('-l file') {|v| opt_h["-l"] << v }
-      opt.on('-L path') {|v| opt_h["-L"] << v }
-      opt.on('-x pat', "--x pat") {|v| opt_h["-x"] << v }
-      opt.on('-O num'){|v| opt_h["-O"] << v if /[0-9]/ =~ v }
-      opt.on('--mkmf-cu-ext ext'){|v| opt_h["--mkmf-cu-ext"] << v}
+      opt_h = Hash.new { |h, k| h[k] = [] }
+
+      opt.on("--arch arg") { |v| opt_h["-arch"] << v }
+      opt.on("--std arg") { |v| opt_h["-std"] << v }
+      opt.on("--stdlib arg") { |v| opt_h["-stdlib"] << v }
+
+      opt.on("--Wl arg") { |v| opt_h["-Wl"] << v }
+
+      opt.on('--profile') { |v| opt_h["-pg"] << "" }
+      opt.on('-g') { |v| opt_h["-g"] << "" }
+      opt.on('-G', "--device-debug") { |v| opt_h["-G"] << "" }
+
+      opt.on('-I path') { |v| opt_h["-I"] << quote(v) }
+      opt.on('-D flag') { |v| opt_h["-D"] << v }
+      opt.on('-W flag') { |v| opt_h["-W"] << v }
+      opt.on('-o output') { |v| opt_h["-o"] << quote(v) }
+      opt.on('-c file') { |v| opt_h["-c"] << quote(v) }
+      opt.on('-f flag') { |v| opt_h["-f"] << v }
+      opt.on('-l file') { |v| opt_h["-l"] << quote(v) }
+      opt.on('-L path') { |v| opt_h["-L"] << quote(v) }
+      opt.on('-x pat', "--x pat") { |v| opt_h["-x"] << v }
+      opt.on('-O num') { |v| opt_h["-O"] << v if /[0-9]/ =~ v }
+      opt.on('--mkmf-cu-ext ext') { |v| opt_h["--mkmf-cu-ext"] << v }
 
       return [opt, opt_h]
     end
 
     def parse_ill_short(argv, opt_h)
-      ["-shared", "-rdynamic", "-dynamic", "-bundle",  "-pipe", "-pg", "-ggdb3"].each{|opt|
+      ["-shared", "-rdynamic", "-dynamic", "-bundle", "-pipe", "-pg", "-ggdb3"].each { |opt|
         if ind = argv.find_index(opt)
           opt_h[opt] << ""
           argv.delete_at(ind)
         end
       }
-      ["-arch", "-std", "-stdlib"].each{|opt|
+      ["-arch", "-std", "-stdlib"].each { |opt|
         if ind = argv.find_index(opt)
           argv[ind] = "-" + opt
         end
       }
     end
 
-    def parse_ill_short_with_arg(argv, opt_h)  
-      [/\A(\-stdlib)=(.*)/, /\A(\-std)=(.*)/, /\A(\-Wl),(.*)/].each{|reg|
-        argv.each{|e|
+    def parse_ill_short_with_arg(argv, opt_h)
+      [/\A(\-stdlib)=(.*)/, /\A(\-std)=(.*)/, /\A(\-Wl),(.*)/].each { |reg|
+        argv.each { |e|
           if reg =~ e
             e[0..-1] = "-" + $1 + '=' + $2
           end
@@ -81,14 +83,14 @@ module MakeMakefileCuda
     end
 
     def compiler_option(opt_h)
-      ret = ""
-      ["-f", "-W", "-pipe"].each{|op|
-        opt_h[op].each{|e|
+      ret = +""
+      ["-f", "-W", "-pipe"].each { |op|
+        opt_h[op].each { |e|
           ret << " --compiler-options " + "#{op}#{e}"
         }
       }
-      ["-stdlib", "-std"].each{|op|
-        opt_h[op].each{|e|
+      ["-stdlib", "-std"].each { |op|
+        opt_h[op].each { |e|
           ret << " --compiler-options " + "#{op}=#{e}"
         }
       }
@@ -96,13 +98,13 @@ module MakeMakefileCuda
     end
 
     def linker_option(opt_h)
-      ret = " -shared "
-      ["-dynamic", "-bundle"].each{|op|
-        opt_h[op].each{|e|
+      ret = +" -shared "
+      ["-dynamic", "-bundle"].each { |op|
+        opt_h[op].each { |e|
           ret << " --linker-options " + op
         }
       }
-      opt_h["-Wl"].each{|e|
+      opt_h["-Wl"].each { |e|
         ret << " --linker-options " + e
       }
       return ret
@@ -110,17 +112,17 @@ module MakeMakefileCuda
 
     def compiler_bin(opt_h)
       if opt_h["--mkmf-cu-ext"][0] == "c"
-        " --compiler-bindir " + RbConfig::CONFIG["CC"]
+        " --compiler-bindir " + ENV.fetch("NVCC_CCBIN", RbConfig::CONFIG["CC"])
       elsif opt_h["--mkmf-cu-ext"][0] == "cxx"
-        " --compiler-bindir " + RbConfig::CONFIG["CXX"]
+        " --compiler-bindir " + ENV.fetch("NVCC_CCBIN", RbConfig::CONFIG["CXX"])
       end
     end
 
     def generate_compiling_command_line(opt_h)
-      s = ""
+      s = +""
       # options nvcc can uderstatnd
-      ["-std", "-pg", "-g", "-G", "-x", "-I", "-D", "-o", "-c", "-O"].each{|op|
-        opt_h[op].each{|e|
+      ["-std", "-pg", "-g", "-G", "-x", "-I", "-D", "-o", "-c", "-O"].each { |op|
+        opt_h[op].each { |e|
           case op
           when "-o", "-c", "-x", "-std"
             s << " #{op} #{e}"
@@ -136,9 +138,9 @@ module MakeMakefileCuda
     end
 
     def generate_linking_command_line(argv, opt_h)
-      s = ""
-      ["-L", "-l", "-o", "-c", "-O"].each{|op|
-        opt_h[op].each{|e|
+      s = +""
+      ["-L", "-l", "-o", "-c", "-O"].each { |op|
+        opt_h[op].each { |e|
           case op
           when "-o", "-c"
             s << " #{op} #{e}"
@@ -153,5 +155,9 @@ module MakeMakefileCuda
       s << compiler_bin(opt_h)
       return s
     end
+
+    def quote(str)
+      "\"#{str}\""
+    end
   end
 end

data/3rd_party/mkmf-cu/lib/mkmf-cu.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "mkmf"
 
 module MakeMakefileCuda

data/3rd_party/mkmf-cu/mkmf-cu.gemspec

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 Gem::Specification.new do |s|
   s.name        = 'mkmf-cu'
   s.version     = '0.1.2'
   s.date        = '2016-03-26'
   s.summary     = "Write Ruby extension in C/C++ with NVIDIA CUDA."
   s.description =
-  "Write Ruby extension in C/C++ with NVIDIA CUDA. A simple wrapper command for nvcc and a monkey patch for mkmf."
+    "Write Ruby extension in C/C++ with NVIDIA CUDA. A simple wrapper command for nvcc and a monkey patch for mkmf."
   s.authors     = ["Takashi Tamura"]
   s.email       = ''
   s.files       = ["lib/mkmf-cu.rb", "lib/mkmf-cu/opt.rb", "LICENSE", "README.md"]

data/3rd_party/mkmf-cu/test/test_mkmf-cu.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "test/unit"
 require "mkmf-cu/opt"
 require "mkmf-cu"
@@ -23,7 +25,7 @@ class TestMkmfCuOpt < Test::Unit::TestCase
   end
 
   def test_compiler_option
-    @opt_h.merge!({"-shared"=>[""], "-pipe"=>[""]})
+    @opt_h.merge!({"-shared" => [""], "-pipe" => [""]})
     assert_equal(" --compiler-options -pipe", compiler_option(@opt_h))
   end
 
@@ -37,7 +39,7 @@ class TestMkmfCuOpt < Test::Unit::TestCase
   end
 
   def test_linker_option
-    @opt_h.merge!({"-Wl"=>["-a", "-b"]})
+    @opt_h.merge!({"-Wl" => ["-a", "-b"]})
     assert_equal(" --linker-options -a --linker-options -b",
                  linker_option(@opt_h))
   end
@@ -50,7 +52,7 @@ class TestMkmfCuOpt < Test::Unit::TestCase
   end
 
   def test_compiler_bin
-    h = Hash.new{|h, k| h[k] = [] }.merge({"-shared"=>[""], "-pipe"=>[""], "--mkmf-cu-ext"=>["c"]})
+    h = Hash.new { |h, k| h[k] = [] }.merge({"-shared" => [""], "-pipe" => [""], "--mkmf-cu-ext" => ["c"]})
     assert_equal(" --compiler-bindir " + RbConfig::CONFIG["CC"],
                  compiler_bin(h))
   end

data/CHANGELOG.md

@@ -1,3 +1,72 @@
+# 0.5.0 (2025/11/01)
+
+Fixes:
+
+* Remove unnecessary numo-narray dependency
+* Fix Errno::EXDEV for Invalid cross-device link
+* Remove clobber from default task
+* Enable parallel build by default
+* Add magic comment for frozen_string_literal
+* Backport: fix na_flatten_dim(): SEGV when flattening an empty narray view
+* Backport: bug in reshape!: stridx in NArrayView should be reconstructed
+* Backport: mask and masked arrays must have the same shape
+* Backport: fix na_parse_range() to suppress warnings
+* Backport: FIXNUM length is based on LONG, not VALUE
+* Backport: fix bug in NArray#sort: qsort() does not support strided loop
+* Backport: fix na_aref_md_protected(): na2->stridx should be zero-inizialized
+* Backport: q[i].idx should be freed when i != ndim-1
+* Backport: fix variable type
+* Backport: add tests for Bit view arrays
+* Backport: fix macro: STORE_BIT STORE_BIT_STEP: requires mask to leave the lowest bit
+* Backport: fix NArray::Bit#any?,all?: empty array should return false
+* Backport: fix NArray::Bit#count_true/false: empty array should return zero
+* Backport: bug in NArray::Bit; fix bit operation in tmpl_bit/{store_bit,unary,binary}.c
+* Fix typo
+* Backport 135: Make all empty arrays equal
+* Backport: minor fixes in na_get_result_dimension(), check_index_count()
+* Backport 116: new method: NArray#fortran_contiguous?
+* Backport 186: Fix NMath.sinc(0)
+* Backport 188: Fix a typo
+* Fix FrozenError
+* Use add_dependency instead of add_runtime_dependency
+* Remove unused variable
+* Remove unused .travis.yml
+* Remove unnecessary require to fix warnings of "loading in progress, circular require considered harmful"
+* Remove unused variable
+* Fix numo-narray library path
+* Add extconf_compile_commands_json as development dependency
+* Add extconf_compile_commands_json for clangd LSP
+* Remove unnecessary loop if disable assert()
+* Fix cross-platform negative value conversion for unsigned integer types
+* Revert "Fix cross-platform negative value conversion for unsigned integer types"
+* Remove unnecessary require
+* Add Ractor support
+* Update minimum CUDA version
+* Update minimum ruby supported version
+* Use rake-compiler
+* Use absolute file path
+* Allow convert nil to NaN in Numo::DFloat.cast
+* Fix cross-platform negative value conversion for unsigned integer types
+* Fix old-style function definitions
+* Fix old-style function definition in qsort.c
+* Add required_ruby_version in gemspec
+* Use released version of power_assert gem
+* Fix LoadError
+* Quoted file path
+* Add CUDA compute capability (#151)
+* extconf.rb: Use File::PATH_SEPARATOR
+* Fix build error with cuDNN features
+* Link c++ library
+* Fix link error with "multiple definition of `cumo_cuda_eCudnnError'"
+* Fix failure with Ruby 3.3
+* Fix keyword argument expansion
+* Remove compute_35 because it was removed at CUDA 12
+* Use NVCC_CCBIN env var to detect compiler for cuda code on GCC 15 environment
+* Fix build error with GCC 15
+* Use rb_cObject instead of rb_cData
+* Remove unnecessary dependency
+* at() method was rewritten in C.
+
 # 0.4.3 (2019-06-11)
 
 Fixes:

data/Gemfile

@@ -1,8 +1,13 @@
+# frozen_string_literal: true
+
 source "https://rubygems.org"
 
 gemspec
 
+gem 'extconf_compile_commands_json'
+gem 'rake-compiler'
 gem 'test-unit'
 gem 'yard'
 gem 'pry-byebug'
-gem 'power_assert', git: 'https://github.com/k-tsj/power_assert'
+gem 'power_assert'
+gem 'rubocop'

data/README.md

@@ -6,9 +6,9 @@ Cumo (pronounced "koomo") is a CUDA-aware, GPU-optimized numerical library that
 
 ## Requirements
 
-* Ruby 2.5 or later
+* Ruby 3.0 or later
 * NVIDIA GPU Compute Capability 3.5 (Kepler) or later
-* CUDA 9.0 or later
+* CUDA 11.0 or later
 
 ## Preparation
 
@@ -195,14 +195,6 @@ ln -sf "$HOME/opt/ccache/bin/ccache" "$HOME/opt/ccache/bin/g++"
 ln -sf "$HOME/opt/ccache/bin/ccache" "$HOME/opt/ccache/bin/nvcc"
 ```
 
-### Build in parallel
-
-Set `MAKEFLAGS` to specify `make` command options. You can build in parallel as:
-
-```
-bundle exec env MAKEFLAG=-j8 rake compile
-```
-
 ### Specify nvcc --generate-code options
 
 ```

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "bundler/gem_tasks"
 require "rake/testtask"
 
@@ -7,22 +9,17 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList["test/**/*_test.rb"]
 end
 
-task :compile do
-  sh 'cd ext/cumo && ruby extconf.rb && make && make build-ctest'
-end
+require "rake/extensiontask"
+Rake::ExtensionTask.new("cumo")
 
 task :ctest do
-  sh 'cd ext/cumo && ruby extconf.rb && make run-ctest'
-end
-
-task :clean do
-  sh 'cd ext/cumo && make clean'
+  sh 'cd ext/cumo && ruby extconf.rb && make && make build-ctest && make run-ctest'
 end
 
 task :docs do
   dir = "ext/cumo"
-  srcs = %w[array.c data.c index.c math.c narray.c rand.c struct.c].map{|s| File.join(dir, "narray", s)}
-  srcs += %w[cublas.c driver.c nvrtc.c runtime.c memory_pool.cpp].map{|s| File.join(dir, "cuda", s) }
+  srcs = %w[array.c data.c index.c math.c narray.c rand.c struct.c].map { |s| File.join(dir, "narray", s) }
+  srcs += %w[cublas.c driver.c nvrtc.c runtime.c memory_pool.cpp].map { |s| File.join(dir, "cuda", s) }
   srcs << File.join(dir, "narray", "types/*.c")
   srcs << "lib/cumo/narray/extra.rb"
   sh "cd ext/cumo; ruby extconf.rb; make src"
@@ -34,7 +31,7 @@ task :gdb do
   sh "gdb -x run.gdb --args ruby -I. ./test.rb"
 end
 
-task :default => [:clobber, :compile, :test]
+task :default => [:compile, :test]
 
 desc 'Open an irb session preloaded with the gem library'
 task :console do

data/bench/broadcast_fp32.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 require 'benchmark'
 require 'cumo/narray'
 
 num_iteration = 1000
 
 Benchmark.bm 20 do |r|
-  x = Cumo::SFloat.ones([1000,784])
-  y = Cumo::SFloat.ones([1000,784])
+  x = Cumo::SFloat.ones([1000, 784])
+  y = Cumo::SFloat.ones([1000, 784])
   r.report "x.inplace + y" do
     num_iteration.times do
       x.inplace + y
@@ -13,8 +15,8 @@ Benchmark.bm 20 do |r|
     Cumo::CUDA::Runtime.cudaDeviceSynchronize
   end
 
-  x = Cumo::SFloat.ones([1000,784])
-  y = Cumo::SFloat.ones([1000,784])
+  x = Cumo::SFloat.ones([1000, 784])
+  y = Cumo::SFloat.ones([1000, 784])
   r.report "x + y" do
     num_iteration.times do
       (x + y).free
@@ -22,8 +24,8 @@ Benchmark.bm 20 do |r|
     Cumo::CUDA::Runtime.cudaDeviceSynchronize
   end
 
-  x = Cumo::SFloat.ones([1000,784])
-  y = Cumo::SFloat.ones([1000,784])
+  x = Cumo::SFloat.ones([1000, 784])
+  y = Cumo::SFloat.ones([1000, 784])
   r.report "x.inplace + 1.0" do
     num_iteration.times do
       x.inplace + 1.0
@@ -31,8 +33,8 @@ Benchmark.bm 20 do |r|
     Cumo::CUDA::Runtime.cudaDeviceSynchronize
   end
 
-  x = Cumo::SFloat.ones([1000,784])
-  z = Cumo::SFloat.ones([1000,1])
+  x = Cumo::SFloat.ones([1000, 784])
+  z = Cumo::SFloat.ones([1000, 1])
   r.report "x.inplace + z" do
     num_iteration.times do
       x.inplace + z
@@ -40,8 +42,8 @@ Benchmark.bm 20 do |r|
     Cumo::CUDA::Runtime.cudaDeviceSynchronize
   end
 
-  x = Cumo::SFloat.ones([1000,784])
-  y = Cumo::SFloat.ones([1000,784])
+  x = Cumo::SFloat.ones([1000, 784])
+  y = Cumo::SFloat.ones([1000, 784])
   r.report "x.inplace - y" do
     num_iteration.times do
       x.inplace - y
@@ -49,8 +51,8 @@ Benchmark.bm 20 do |r|
     Cumo::CUDA::Runtime.cudaDeviceSynchronize
   end
 
-  x = Cumo::SFloat.ones([1000,784])
-  y = Cumo::SFloat.ones([1000,784])
+  x = Cumo::SFloat.ones([1000, 784])
+  y = Cumo::SFloat.ones([1000, 784])
   r.report "x.inplace - 1.0" do
     num_iteration.times do
       x.inplace - 1.0
@@ -58,8 +60,8 @@ Benchmark.bm 20 do |r|
     Cumo::CUDA::Runtime.cudaDeviceSynchronize
   end
 
-  x = Cumo::SFloat.ones([1000,784])
-  z = Cumo::SFloat.ones([1000,1])
+  x = Cumo::SFloat.ones([1000, 784])
+  z = Cumo::SFloat.ones([1000, 1])
   r.report "x.inplace - z" do
     num_iteration.times do
       x.inplace - z
@@ -67,8 +69,8 @@ Benchmark.bm 20 do |r|
     Cumo::CUDA::Runtime.cudaDeviceSynchronize
   end
 
-  x = Cumo::SFloat.ones([1000,784])
-  y = Cumo::SFloat.ones([1000,784])
+  x = Cumo::SFloat.ones([1000, 784])
+  y = Cumo::SFloat.ones([1000, 784])
   r.report "x.inplace * y" do
     num_iteration.times do
       x.inplace * y
@@ -76,8 +78,8 @@ Benchmark.bm 20 do |r|
     Cumo::CUDA::Runtime.cudaDeviceSynchronize
   end
 
-  x = Cumo::SFloat.ones([1000,784])
-  y = Cumo::SFloat.ones([1000,784])
+  x = Cumo::SFloat.ones([1000, 784])
+  y = Cumo::SFloat.ones([1000, 784])
   r.report "x.inplace * 1.0" do
     num_iteration.times do
       x.inplace * 1.0
@@ -85,8 +87,8 @@ Benchmark.bm 20 do |r|
     Cumo::CUDA::Runtime.cudaDeviceSynchronize
   end
 
-  x = Cumo::SFloat.ones([1000,784])
-  z = Cumo::SFloat.ones([1000,1])
+  x = Cumo::SFloat.ones([1000, 784])
+  z = Cumo::SFloat.ones([1000, 1])
   r.report "x.inplace * z" do
     num_iteration.times do
       x.inplace * z
@@ -94,8 +96,8 @@ Benchmark.bm 20 do |r|
     Cumo::CUDA::Runtime.cudaDeviceSynchronize
   end
 
-  x = Cumo::SFloat.ones([1000,784])
-  y = Cumo::SFloat.ones([1000,784])
+  x = Cumo::SFloat.ones([1000, 784])
+  y = Cumo::SFloat.ones([1000, 784])
   r.report "x.inplace / y" do
     num_iteration.times do
       x.inplace / y
@@ -103,8 +105,8 @@ Benchmark.bm 20 do |r|
     Cumo::CUDA::Runtime.cudaDeviceSynchronize
   end
 
-  x = Cumo::SFloat.ones([1000,784])
-  y = Cumo::SFloat.ones([1000,784])
+  x = Cumo::SFloat.ones([1000, 784])
+  y = Cumo::SFloat.ones([1000, 784])
   r.report "x.inplace / 1.0" do
     num_iteration.times do
       x.inplace / 1.0
@@ -112,8 +114,8 @@ Benchmark.bm 20 do |r|
     Cumo::CUDA::Runtime.cudaDeviceSynchronize
   end
 
-  x = Cumo::SFloat.ones([1000,784])
-  z = Cumo::SFloat.ones([1000,1])
+  x = Cumo::SFloat.ones([1000, 784])
+  z = Cumo::SFloat.ones([1000, 1])
   r.report "x.inplace / z" do
     num_iteration.times do
       x.inplace / z