cumo 0.1.0

data/bench/reduction_fp32.rb

@@ -0,0 +1,117 @@
+require 'benchmark'
+require 'cumo/narray'
+
+num_iteration = 100
+Cumo::CUDA::Runtime.cudaDeviceSynchronize
+
+Benchmark.bm 30 do |r|
+  x = Cumo::SFloat.ones([500,500])
+  r.report "x.sum" do
+    num_iteration.times do
+      x.sum
+    end
+    Cumo::CUDA::Runtime.cudaDeviceSynchronize
+  end
+
+  x = Cumo::SFloat.ones([500,500])
+  r.report "x.sum(axis: 0)" do
+    num_iteration.times do
+      x.sum(axis: 0)
+    end
+    Cumo::CUDA::Runtime.cudaDeviceSynchronize
+  end
+
+  x = Cumo::SFloat.ones([500,500])
+  r.report "x.sum(axis: 1)" do
+    num_iteration.times do
+      x.sum(axis: 1)
+    end
+    Cumo::CUDA::Runtime.cudaDeviceSynchronize
+  end
+
+  x = Cumo::SFloat.ones([500,500])
+  r.report "x.sum(keepdims: true)" do
+    num_iteration.times do
+      x.sum(keepdims: true)
+    end
+    Cumo::CUDA::Runtime.cudaDeviceSynchronize
+  end
+
+  x = Cumo::SFloat.ones([500,500])
+  r.report "x.sum(axis: 0, keepdims: true)" do
+    num_iteration.times do
+      x.sum(axis: 0, keepdims: true)
+    end
+    Cumo::CUDA::Runtime.cudaDeviceSynchronize
+  end
+
+  x = Cumo::SFloat.ones([500,500])
+  r.report "x.sum(axis: 1, keepdims: true)" do
+    num_iteration.times do
+      x.sum(axis: 1, keepdims: true)
+    end
+    Cumo::CUDA::Runtime.cudaDeviceSynchronize
+  end
+
+  x = Cumo::SFloat.ones([500,500])
+  r.report "x.max" do
+    num_iteration.times do
+      x.max
+    end
+    Cumo::CUDA::Runtime.cudaDeviceSynchronize
+  end
+
+  x = Cumo::SFloat.ones([500,500])
+  r.report "x.max(axis: 0)" do
+    num_iteration.times do
+      x.max(axis: 0)
+    end
+    Cumo::CUDA::Runtime.cudaDeviceSynchronize
+  end
+
+  x = Cumo::SFloat.ones([500,500])
+  r.report "x.max(axis: 1)" do
+    num_iteration.times do
+      x.max(axis: 1)
+    end
+    Cumo::CUDA::Runtime.cudaDeviceSynchronize
+  end
+
+  x = Cumo::SFloat.ones([500,500])
+  r.report "x.max(keepdims: true)" do
+    num_iteration.times do
+      x.max(keepdims: true)
+    end
+    Cumo::CUDA::Runtime.cudaDeviceSynchronize
+  end
+
+  x = Cumo::SFloat.ones([500,500])
+  r.report "x.max(axis: 0, keepdims: true)" do
+    num_iteration.times do
+      x.max(axis: 0, keepdims: true)
+    end
+    Cumo::CUDA::Runtime.cudaDeviceSynchronize
+  end
+
+  x = Cumo::SFloat.ones([500,500])
+  r.report "x.max(axis: 1, keepdims: true)" do
+    num_iteration.times do
+      x.max(axis: 1, keepdims: true)
+    end
+    Cumo::CUDA::Runtime.cudaDeviceSynchronize
+  end
+end
+
+#                                      user     system      total        real
+# x.sum                            0.170000   0.020000   0.190000 (  0.188164)
+# x.sum(axis: 0)                   0.070000   0.010000   0.080000 (  0.081719)
+# x.sum(axis: 1)                   0.060000   0.020000   0.080000 (  0.080435)
+# x.sum(keepdims: true)            0.120000   0.040000   0.160000 (  0.153970)
+# x.sum(axis: 0, keepdims: true)   0.070000   0.010000   0.080000 (  0.083349)
+# x.sum(axis: 1, keepdims: true)   0.080000   0.010000   0.090000 (  0.083299)
+# x.max                            0.140000   0.020000   0.160000 (  0.158882)
+# x.max(axis: 0)                   0.080000   0.000000   0.080000 (  0.081502)
+# x.max(axis: 1)                   0.080000   0.000000   0.080000 (  0.080473)
+# x.max(keepdims: true)            0.140000   0.020000   0.160000 (  0.159530)
+# x.max(axis: 0, keepdims: true)   0.070000   0.020000   0.090000 (  0.083434)
+# x.max(axis: 1, keepdims: true)   0.080000   0.000000   0.080000 (  0.083299)

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "cumo"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/cumo.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+cumo_version = File.read(File.join(__dir__, "ext/cumo/include/cumo.h")).match(/CUMO_VERSION "([\d.]+)"/)[1]
+numo_narray_version = File.read(File.join(__dir__, "numo-narray-version")).strip
+
+Gem::Specification.new do |spec|
+  spec.name          = "cumo"
+  spec.version       = cumo_version
+  spec.authors       = ["Naotoshi Seo"]
+  spec.email         = ["sonots@gmail.com"]
+
+  spec.summary       = %q{Cumo is CUDA aware numerical library whose interface is highly compatible with Ruby Numo}
+  spec.description   = %q{Cumo is CUDA aware numerical library whose interface is highly compatible with Ruby Numo.}
+  spec.homepage      = "https://github.com/sonots/cumo"
+  spec.license       = "BSD-3-Clause"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.extensions    = ["ext/cumo/extconf.rb"]
+
+  spec.add_runtime_dependency "numo-narray", numo_narray_version
+
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/ext/cumo/cuda/cublas.c

@@ -0,0 +1,278 @@
+#include "cumo/cuda/cublas.h"
+
+#include <assert.h>
+#include <ruby.h>
+#include "cumo/narray.h"
+#include "cumo/template.h"
+
+//static void *blas_handle = 0;
+//static char *blas_prefix = 0;
+
+VALUE
+cumo_cublas_option_value(VALUE value, VALUE default_value)
+{
+    switch(TYPE(value)) {
+    case T_NIL:
+    case T_UNDEF:
+        return default_value;
+    }
+    return value;
+}
+
+//enum CBLAS_ORDER
+//cumo_cublas_option_order(VALUE order)
+//{
+//    int opt;
+//    char *ptr;
+//
+//    switch(TYPE(order)) {
+//    case T_NIL:
+//    case T_UNDEF:
+//    case T_FALSE:
+//        return CblasRowMajor;
+//    case T_TRUE:
+//        return CblasColMajor;
+//    case T_FIXNUM:
+//        opt = FIX2INT(order);
+//        if (opt >= CblasRowMajor && opt <= CblasColMajor) {
+//            return opt;
+//        }
+//        break;
+//    case T_SYMBOL:
+//        order = rb_sym2str(order);
+//    case T_STRING:
+//        ptr = RSTRING_PTR(order);
+//        if (RSTRING_LEN(order) > 0) {
+//            switch(ptr[0]){
+//            case 'R': case 'r':
+//                return CblasRowMajor;
+//            case 'C': case 'c':
+//                return CblasColMajor;
+//            }
+//        }
+//        break;
+//    }
+//    rb_raise(rb_eArgError,"invalid value for CBLAS_ORDER");
+//    return 0;
+//}
+
+cublasOperation_t
+cumo_cublas_option_trans(VALUE trans)
+{
+    int opt;
+    char *ptr;
+
+    switch(TYPE(trans)) {
+    case T_NIL:
+    case T_UNDEF:
+    case T_FALSE:
+        return CUBLAS_OP_N;
+    case T_TRUE:
+        return CUBLAS_OP_T;
+    case T_FIXNUM:
+        opt = FIX2INT(trans);
+        if (opt >= CUBLAS_OP_N && opt <= CUBLAS_OP_C) {
+            return opt;
+        }
+        break;
+    case T_SYMBOL:
+        trans = rb_sym2str(trans);
+    case T_STRING:
+        ptr = RSTRING_PTR(trans);
+        if (RSTRING_LEN(trans) > 0) {
+            switch(ptr[0]){
+            case 'N': case 'n':
+                return CUBLAS_OP_N;
+            case 'T': case 't':
+                return CUBLAS_OP_T;
+            case 'C': case 'c':
+                return CUBLAS_OP_C;
+            }
+        }
+        break;
+    }
+    rb_raise(rb_eArgError, "invalid value for cublasOperation_t");
+    return 0;
+}
+
+cublasFillMode_t
+cumo_cublas_option_uplo(VALUE uplo)
+{
+    int opt;
+    char *ptr;
+
+    switch(TYPE(uplo)) {
+    case T_NIL:
+    case T_UNDEF:
+    case T_FALSE:
+        return CUBLAS_FILL_MODE_UPPER;
+    case T_TRUE:
+        return CUBLAS_FILL_MODE_LOWER;
+    case T_FIXNUM:
+        opt = FIX2INT(uplo);
+        switch(opt){
+        case CUBLAS_FILL_MODE_UPPER:
+        case CUBLAS_FILL_MODE_LOWER:
+            return opt;
+        }
+        break;
+    case T_SYMBOL:
+        uplo = rb_sym2str(uplo);
+    case T_STRING:
+        ptr = RSTRING_PTR(uplo);
+        if (RSTRING_LEN(uplo) > 0) {
+            switch(ptr[0]){
+            case 'U': case 'u':
+                return CUBLAS_FILL_MODE_UPPER;
+            case 'L': case 'l':
+                return CUBLAS_FILL_MODE_LOWER;
+            }
+        }
+        break;
+    }
+    rb_raise(rb_eArgError, "invalid value for cublasFillMode_t");
+    return 0;
+}
+
+cublasDiagType_t
+cumo_cublas_option_diag(VALUE diag)
+{
+    int opt;
+    char *ptr;
+
+    switch(TYPE(diag)) {
+    case T_NIL:
+    case T_UNDEF:
+    case T_FALSE:
+        return CUBLAS_DIAG_NON_UNIT;
+    case T_TRUE:
+        return CUBLAS_DIAG_UNIT;
+    case T_FIXNUM:
+        opt = FIX2INT(diag);
+        switch(opt){
+        case CUBLAS_DIAG_NON_UNIT:
+        case CUBLAS_DIAG_UNIT:
+            return opt;
+        }
+        break;
+    case T_SYMBOL:
+        diag = rb_sym2str(diag);
+    case T_STRING:
+        ptr = RSTRING_PTR(diag);
+        if (RSTRING_LEN(diag) > 0) {
+            switch(ptr[0]){
+            case 'N': case 'n':
+                return CUBLAS_DIAG_NON_UNIT;
+            case 'U': case 'u':
+                return CUBLAS_DIAG_UNIT;
+            }
+        }
+        break;
+    }
+    rb_raise(rb_eArgError, "invalid value for cublasDiagType_t");
+    return 0;
+}
+
+cublasSideMode_t
+cumo_cublas_option_side(VALUE side)
+{
+    int opt;
+    char *ptr;
+
+    switch(TYPE(side)) {
+    case T_NIL:
+    case T_UNDEF:
+    case T_FALSE:
+        return CUBLAS_SIDE_LEFT;
+    case T_TRUE:
+        return CUBLAS_SIDE_RIGHT;
+    case T_FIXNUM:
+        opt = FIX2INT(side);
+        switch(opt){
+        case CUBLAS_SIDE_LEFT:
+        case CUBLAS_SIDE_RIGHT:
+            return opt;
+        }
+        break;
+    case T_SYMBOL:
+        side = rb_sym2str(side);
+    case T_STRING:
+        ptr = RSTRING_PTR(side);
+        if (RSTRING_LEN(side) > 0) {
+            switch(ptr[0]){
+            case 'L': case 'l':
+                return CUBLAS_SIDE_LEFT;
+            case 'R': case 'r':
+                return CUBLAS_SIDE_RIGHT;
+            }
+        }
+        break;
+    }
+    rb_raise(rb_eArgError, "invalid value for cublasSideMode_t");
+    return 0;
+}
+
+//void
+//cumo_cublas_check_func(void **func, const char *name)
+//{
+//    char *s, *error;
+//
+//    if (*func==0) {
+//        if (blas_handle==0) {
+//            rb_raise(rb_eRuntimeError,"BLAS library is not loaded");
+//        }
+//        if (blas_prefix==0) {
+//            rb_raise(rb_eRuntimeError,"CBLAS prefix is not set");
+//        }
+//        s = alloca(strlen(blas_prefix)+strlen(name)+1);
+//        strcpy(s,blas_prefix);
+//        strcat(s,name);
+//        dlerror();
+//        *func = dlsym(blas_handle, s);
+//        error = dlerror();
+//        if (error != NULL) {
+//            rb_raise(rb_eRuntimeError, "%s", error);
+//        }
+//    }
+//}
+
+//static VALUE
+//blas_s_prefix_set(VALUE mod, VALUE prefix)
+//{
+//    long len;
+//
+//    if (TYPE(prefix) != T_STRING) {
+//        rb_raise(rb_eTypeError,"argument must be string");
+//    }
+//    if (blas_prefix) {
+//        free(blas_prefix);
+//    }
+//    len = RSTRING_LEN(prefix);
+//    blas_prefix = malloc(len+1);
+//    strcpy(blas_prefix, StringValueCStr(prefix));
+//    return prefix;
+//}
+
+//void
+//Init_blas(void)
+//{
+//    VALUE mN;
+//
+//    mN = rb_define_module("Numo");
+//    /*
+//      Document-module: Numo::Linalg
+//    */
+//    mLinalg = rb_define_module_under(mN, "Linalg");
+//    mBlas = rb_define_module_under(mLinalg, "Blas");
+//
+//    rb_define_module_function(mBlas, "dlopen", blas_s_dlopen, -1);
+//    rb_define_module_function(mBlas, "prefix=", blas_s_prefix_set, 1);
+//
+//    blas_prefix = malloc(strlen("cublas_")+1); // default prefix
+//    strcpy(blas_prefix,"cublas_");
+//
+//    Init_cumo_linalg_blas_s();
+//    Init_cumo_linalg_blas_d();
+//    Init_cumo_linalg_blas_c();
+//    Init_cumo_linalg_blas_z();
+//}