cumo 0.1.0 → 0.1.1

data/bench/numo_bench.rb

@@ -8,8 +8,9 @@ a = Numo::Float32.new(10).seq(1)
 b = Numo::Float32.new(10).seq(10,10)
 c = a + b
 
-def elementwise
-  puts 'element-wise'
+def elementwise(num = nil)
+  num ||= NUM
+  puts "elementwise(#{num})"
   Benchmark.bm do |r|
     a = Numo::Float32.new(10000).seq(1)
     b = Numo::Float32.new(10000).seq(10,10)
@@ -43,8 +44,9 @@ def elementwise
   end
 end
 
-def reduction
-  puts 'reduction'
+def reduction(num = nil)
+  num ||= NUM
+  puts "reduction(#{num})"
   Benchmark.bm do |r|
     a = Numo::Float32.new(10000).seq(1)
     r.report('10**4') do
@@ -73,9 +75,9 @@ def reduction
   end
 end
 
-def dot
-  num = 3
-  puts 'dot'
+def dot(num = nil)
+  num ||= 1
+  puts "dot(#{num})"
   Benchmark.bm do |r|
     a = Numo::Float32.new(100,100).seq(1)
     b = Numo::Float32.new(100,100).seq(10,10)
@@ -115,24 +117,24 @@ dot
 
 # Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz
 #
-# element-wise
+# elementwise(100)
 #        user     system      total        real
-# 10**4  0.010000   0.000000   0.010000 (  0.002212)
-# 10**5  0.000000   0.020000   0.020000 (  0.021604)
-# 10**6  0.060000   0.060000   0.120000 (  0.120241)
-# 10**7  0.980000   0.890000   1.870000 (  1.874592)
-# 10**8  9.530000   8.520000  18.050000 ( 18.054087)
-# reduction
+# 10**4  0.010000   0.000000   0.010000 (  0.002368)
+# 10**5  0.000000   0.020000   0.020000 (  0.024129)
+# 10**6  0.080000   0.050000   0.130000 (  0.139918)
+# 10**7  1.230000   1.020000   2.250000 (  2.251331)
+# 10**8 10.090000   8.560000  18.650000 ( 18.646369)
+# reduction(100)
 #        user     system      total        real
-# 10**4  0.000000   0.000000   0.000000 (  0.001313)
-# 10**5  0.010000   0.000000   0.010000 (  0.011400)
-# 10**6  0.110000   0.000000   0.110000 (  0.111674)
-# 10**7  1.120000   0.000000   1.120000 (  1.127018)
-# 10**8 11.770000   0.010000  11.780000 ( 11.770858)
-# dot
+# 10**4  0.000000   0.000000   0.000000 (  0.001360)
+# 10**5  0.020000   0.000000   0.020000 (  0.011455)
+# 10**6  0.110000   0.000000   0.110000 (  0.111708)
+# 10**7  1.130000   0.000000   1.130000 (  1.137357)
+# 10**8 11.830000   0.000000  11.830000 ( 11.832832)
+# dot(1)
 #        user     system      total        real
-# 10**4  0.000000   0.000000   0.000000 (  0.003935)
-# 10**5  0.040000   0.000000   0.040000 (  0.037682)
-# 10**6  0.380000   0.000000   0.380000 (  0.377312)
-# 10**7  3.790000   0.000000   3.790000 (  3.792297)
-# 10**8 38.820000   0.000000  38.820000 ( 38.816987)
+# 10**4  0.010000   0.000000   0.010000 (  0.001390)
+# 10**5  0.010000   0.000000   0.010000 (  0.012563)
+# 10**6  0.120000   0.010000   0.130000 (  0.125406)
+# 10**7  1.270000   0.000000   1.270000 (  1.272804)
+# 10**8 13.000000   0.000000  13.000000 ( 12.990586)

data/docs/src-tree.md

@@ -0,0 +1,16 @@
+# Source code organizations
+
+* `*_kernel.{h,cuh,cu}` files are for device (CUDA kernels).
+    * .cu files are compiled via nvcc.
+    * .cu files define C wrapper functions to launch CUDA kernels to enable to be called from .c files.
+    * Technically, it is not possible to use CRuby API such as `VALUE` in .cu files.
+        * CRuby API is not callable from CUDA kernel because they do not have `__device__` modifier.
+        * nvcc does not support `#include RUBY_EXTCONF_H`, so can not include `ruby.h`.
+    * (RULE) It is allowed to use C++14 codes in .cu files.
+* Rest of `*.{h,c}` files are for host (CPU).
+    * Call C wrapper functions defined in .cu files.
+    * It can use CRuby API.
+    * (RULE) It is not allowed to use C++ codes in host files.
+
+Ruby's `mkmf` (or `extconf.rb`) does not support to specify 3rd compiler such as NVCC for another files of extensions `.cu`.
+Therefore, cumo specify a wrapper command `bin/mkmf-cu-nvcc` as a compiler and changes its behavor depending on extensions of files to compile.

data/ext/cumo/cuda/cublas.c

@@ -4,12 +4,66 @@
 #include <ruby.h>
 #include "cumo/narray.h"
 #include "cumo/template.h"
+#include "cumo/cuda/runtime.h"
 
-//static void *blas_handle = 0;
-//static char *blas_prefix = 0;
+VALUE cumo_cuda_eCublasError;
+VALUE cumo_cuda_mCublas;
+#define eCublasError cumo_cuda_eCublasError
+#define mCublas cumo_cuda_mCublas
+
+static char*
+get_cublas_error_msg(cublasStatus_t error) {
+    switch (error) {
+#define RETURN_MSG(msg) \
+    case msg:                              \
+        return #msg
+
+        RETURN_MSG(CUBLAS_STATUS_SUCCESS);
+        RETURN_MSG(CUBLAS_STATUS_NOT_INITIALIZED);
+        RETURN_MSG(CUBLAS_STATUS_ALLOC_FAILED);
+        RETURN_MSG(CUBLAS_STATUS_INVALID_VALUE);
+        RETURN_MSG(CUBLAS_STATUS_ARCH_MISMATCH);
+        RETURN_MSG(CUBLAS_STATUS_MAPPING_ERROR);
+        RETURN_MSG(CUBLAS_STATUS_EXECUTION_FAILED);
+        RETURN_MSG(CUBLAS_STATUS_INTERNAL_ERROR);
+        RETURN_MSG(CUBLAS_STATUS_NOT_SUPPORTED);
+        RETURN_MSG(CUBLAS_STATUS_LICENSE_ERROR);
+
+#undef RETURN_MSG
+    }
+    abort(); // never reach
+}
+
+void
+cumo_cuda_cublas_check_status(cublasStatus_t status)
+{
+    if (status != 0) {
+        rb_raise(cumo_cuda_eCublasError, "%s (error=%d)", get_cublas_error_msg(status), status);
+    }
+}
+
+// Lazily initialize cublas handle, and cache it
+cublasHandle_t
+cumo_cuda_cublas_handle()
+{
+    static cublasHandle_t *handles = 0;  // handle is never destroyed
+    if (handles == 0) {
+        int i;
+        int device_count = cumo_cuda_runtime_get_device_count();
+        handles = malloc(sizeof(cublasHandle_t) * device_count);
+        for (i = 0; i < device_count; ++i) {
+            handles[i] = 0;
+        }
+    }
+    int device = cumo_cuda_runtime_get_device();
+    if (handles[device] == 0) {
+        cublasCreate(&handles[device]);
+    }
+    return handles[device];
+}
 
 VALUE
-cumo_cublas_option_value(VALUE value, VALUE default_value)
+cumo_cuda_cublas_option_value(VALUE value, VALUE default_value)
 {
     switch(TYPE(value)) {
     case T_NIL:
@@ -19,45 +73,9 @@ cumo_cublas_option_value(VALUE value, VALUE 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;
-//}
-
+#if 0
 cublasOperation_t
-cumo_cublas_option_trans(VALUE trans)
+cumo_cuda_cublas_option_trans(VALUE trans)
 {
     int opt;
     char *ptr;
@@ -94,185 +112,17 @@ cumo_cublas_option_trans(VALUE trans)
     rb_raise(rb_eArgError, "invalid value for cublasOperation_t");
     return 0;
 }
+#endif
 
-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)
+void
+Init_cumo_cuda_cublas(void)
 {
-    int opt;
-    char *ptr;
+    VALUE mCumo = rb_define_module("Cumo");
+    VALUE mCUDA = rb_define_module_under(mCumo, "CUDA");
 
-    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;
+    /*
+      Document-module: Cumo::Cublas
+    */
+    mCublas = rb_define_module_under(mCUDA, "Cublas");
+    eCublasError = rb_define_class_under(mCUDA, "CublasError", rb_eStandardError);
 }
-
-//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();
-//}

data/ext/cumo/cuda/memory_pool_impl.hpp

@@ -6,6 +6,7 @@
 #include <memory>
 #include <mutex>
 #include <stdexcept>
+#include <string>
 #include <unordered_map>
 #include <vector>
 

data/ext/cumo/cuda/runtime.c

@@ -64,13 +64,7 @@ rb_cudaRuntimeGetVersion(VALUE self)
 static VALUE
 rb_cudaGetDevice(VALUE self)
 {
-    int _device;
-    cudaError_t status;
-
-    status = cudaGetDevice(&_device);
-
-    check_status(status);
-    return INT2NUM(_device);
+    return INT2NUM(cumo_cuda_runtime_get_device());
 }
 
 /*
@@ -106,13 +100,7 @@ rb_cudaDeviceGetAttributes(VALUE self, VALUE attrib, VALUE device)
 static VALUE
 rb_cudaGetDeviceCount(VALUE self)
 {
-    int _count;
-    cudaError_t status;
-
-    status = cudaGetDeviceCount(&_count);
-
-    check_status(status);
-    return INT2NUM(_count);
+    return INT2NUM(cumo_cuda_runtime_get_device_count());
 }
 
 /*

data/ext/cumo/cumo.c

@@ -7,10 +7,10 @@
 
 void Init_cumo();
 void Init_cumo_narray();
-void Init_cumo_nary_data();
-void Init_cumo_nary_ndloop();
-void Init_cumo_nary_step();
-void Init_cumo_nary_index();
+void Init_cumo_na_data();
+void Init_cumo_na_ndloop();
+void Init_cumo_na_step();
+void Init_cumo_na_index();
 void Init_cumo_bit();
 void Init_cumo_int8();
 void Init_cumo_int16();
@@ -25,10 +25,10 @@ void Init_cumo_scomplex();
 void Init_cumo_dfloat();
 void Init_cumo_dcomplex();
 void Init_cumo_robject();
-void Init_cumo_nary_math();
-void Init_cumo_nary_rand();
-void Init_cumo_nary_array();
-void Init_cumo_nary_struct();
+void Init_cumo_na_math();
+void Init_cumo_na_rand();
+void Init_cumo_na_array();
+void Init_cumo_na_struct();
 void Init_cumo_cuda_driver();
 void Init_cumo_cuda_memory_pool();
 void Init_cumo_cuda_runtime();
@@ -112,11 +112,11 @@ Init_cumo()
 
     Init_cumo_narray();
 
-    Init_cumo_nary_step();
-    Init_cumo_nary_index();
+    Init_cumo_na_step();
+    Init_cumo_na_index();
 
-    Init_cumo_nary_data();
-    Init_cumo_nary_ndloop();
+    Init_cumo_na_data();
+    Init_cumo_na_ndloop();
 
     Init_cumo_dcomplex();
     Init_cumo_dfloat();
@@ -135,11 +135,11 @@ Init_cumo()
     Init_cumo_bit();
     Init_cumo_robject();
 
-    Init_cumo_nary_math();
+    Init_cumo_na_math();
 
-    Init_cumo_nary_rand();
-    Init_cumo_nary_array();
-    Init_cumo_nary_struct();
+    Init_cumo_na_rand();
+    Init_cumo_na_array();
+    Init_cumo_na_struct();
 
     Init_cumo_cuda_driver();
     Init_cumo_cuda_memory_pool();