cumo 0.1.0

data/ext/cumo/depend.erb

@@ -0,0 +1,58 @@
+TAGSRC = \
+ ../../ruby/include/ruby/*.h \
+ ../../ruby/*.c \
+ narray/*.h \
+ narray/types/*.h \
+ narray/*.c \
+ narray/types/*.c \
+ narray/types/*.cu
+
+tags : TAGS
+TAGS : $(TAGSRC)
+	etags $(TAGSRC)
+
+C_TMPL = <%=Dir.glob("narray/gen/tmpl*/*.c").join(" ")%>
+CU_TMPL = <%=Dir.glob("narray/gen/tmpl*/*.cu").join(" ")%>
+
+C_COGEN = narray/gen/cogen.rb
+CU_COGEN = narray/gen/cogen_kernel.rb
+C_DEPENDS = $(C_TMPL) narray/gen/*.rb
+CU_DEPENDS = $(CU_TMPL) narray/gen/*.rb
+
+<%
+list_type_c = []
+list_type_rb = Dir.glob("narray/gen/def/*.rb")
+list_type_rb.each do |type_rb|
+  type_name = File.basename(type_rb, ".rb")
+  next if ENV['DTYPE'] and !type_name.downcase.include?(ENV['DTYPE'].downcase)
+  list_type_c << type_c = "narray/types/" + type_name + ".c"
+%>
+<%=type_c%>: <%=type_rb%> $(C_DEPENDS)
+	$(MAKEDIRS) $(@D) types
+	ruby $(C_COGEN) -l -o $@ <%=type_rb%>
+<% end %>
+
+<%
+list_type_cu = []
+list_type_rb = Dir.glob("narray/gen/def/*.rb")
+list_type_rb.each do |type_rb|
+  type_name = File.basename(type_rb, ".rb")
+  next if ENV['DTYPE'] and !type_name.downcase.include?(ENV['DTYPE'].downcase)
+  list_type_cu << type_cu = "narray/types/" + type_name + "_kernel.cu"
+%>
+<%=type_cu%>: <%=type_rb%> $(CU_DEPENDS)
+	$(MAKEDIRS) $(@D) types
+	ruby $(CU_COGEN) -l -o $@ <%=type_rb%>
+<% end %>
+
+src : <%= list_type_cu.join(" ") %> <%= list_type_c.join(" ") %>
+
+build-ctest : cuda/memory_pool_impl_test.exe
+
+run-ctest : cuda/memory_pool_impl_test.exe
+	./$<
+
+cuda/memory_pool_impl_test.exe: cuda/memory_pool_impl_test.cpp cuda/memory_pool_impl.cpp cuda/memory_pool_impl.hpp
+	nvcc -DNO_RUBY -std=c++14 <%= ENV['DEBUG'] ? '-g -O0 --compiler-options -Wall' : '' %> -L. -L$(libdir) -I. $(INCFLAGS) -o $@ $< cuda/memory_pool_impl.cpp
+
+CLEANOBJS = *.o */*.o */*/*.o *.bak narray/types/*.c narray/types/*_kernel.cu *.exe */*.exe

data/ext/cumo/extconf.rb

@@ -0,0 +1,179 @@
+require 'rbconfig.rb'
+require "erb"
+require_relative '../../3rd_party/mkmf-cu/lib/mkmf-cu'
+
+if RUBY_VERSION < "2.0.0"
+  puts "Cumo::NArray requires Ruby version 2.0 or later."
+  exit(1)
+end
+
+def have_numo_narray!
+  version_path = File.join(__dir__, "..", "..", "numo-narray-version")
+  version = File.read(version_path).strip
+  gem_spec = Gem::Specification.find_by_name("numo-narray", version)
+
+  $INCFLAGS += " -I#{gem_spec.gem_dir}/ext/numo/narray"
+  if !have_header("numo/narray.h")
+    puts "
+    Header numo/narray.h was not found. Give pathname as follows:
+    % ruby extconf.rb --with-narray-include=narray_h_dir"
+    exit(1)
+  end
+
+  if RUBY_PLATFORM =~ /cygwin|mingw/
+    $LDFLAGS += " -L#{gem_spec.gem_dir}/ext/numo"
+    unless have_library("narray","nary_new")
+      puts "libnarray.a not found"
+      exit(1)
+    end
+  end
+end
+
+def create_depend
+  message "creating depend\n"
+  depend_path = File.join(__dir__, "depend")
+  File.open(depend_path, "w") do |depend|
+    depend_erb_path = File.join(__dir__, "depend.erb")
+    File.open(depend_erb_path, "r") do |depend_erb|
+      erb = ERB.new(depend_erb.read)
+      erb.filename = depend_erb_path
+      depend.print(erb.result)
+    end
+  end
+end
+
+rm_f 'include/cumo/extconf.h'
+
+MakeMakefileCuda.install!(cxx: true)
+
+if ENV['DEBUG']
+  $CFLAGS="-g -O0 -Wall"
+end
+$CXXFLAGS += " -std=c++14 "
+#$CFLAGS=" $(cflags) -O3 -m64 -msse2 -funroll-loops"
+#$CFLAGS=" $(cflags) -O3"
+$INCFLAGS = "-Iinclude -Inarray -Icuda #{$INCFLAGS}"
+
+$INSTALLFILES = Dir.glob(%w[include/cumo/*.h include/cumo/types/*.h include/cumo/cuda/*.h]).map{|x| [x,'$(archdir)'] }
+$INSTALLFILES << ['include/cumo/extconf.h','$(archdir)']
+if /cygwin|mingw/ =~ RUBY_PLATFORM
+  $INSTALLFILES << ['libcumo.a', '$(archdir)']
+end
+
+srcs = %w(
+cumo
+narray/narray
+narray/array
+narray/step
+narray/index
+narray/ndloop
+narray/data
+narray/types/bit
+narray/types/int8
+narray/types/int16
+narray/types/int32
+narray/types/int64
+narray/types/uint8
+narray/types/uint16
+narray/types/uint32
+narray/types/uint64
+narray/types/sfloat
+narray/types/dfloat
+narray/types/scomplex
+narray/types/dcomplex
+narray/types/robject
+narray/types/bit_kernel
+narray/types/int8_kernel
+narray/types/int16_kernel
+narray/types/int32_kernel
+narray/types/int64_kernel
+narray/types/uint8_kernel
+narray/types/uint16_kernel
+narray/types/uint32_kernel
+narray/types/uint64_kernel
+narray/types/sfloat_kernel
+narray/types/dfloat_kernel
+narray/types/scomplex_kernel
+narray/types/dcomplex_kernel
+narray/types/robject_kernel
+narray/math
+narray/SFMT
+narray/struct
+narray/rand
+cuda/cublas
+cuda/driver
+cuda/memory_pool
+cuda/memory_pool_impl
+cuda/runtime
+cuda/nvrtc
+)
+
+if RUBY_VERSION[0..3] == "2.1."
+  puts "add kwargs"
+  srcs << "kwargs"
+end
+
+$objs = srcs.map {|src| "#{src}.o" }
+
+dir_config("narray")
+
+have_numo_narray!
+
+if have_header("dlfcn.h")
+  exit(1) unless have_library("dl")
+  exit(1) unless have_func("dlopen")
+elsif have_header("windows.h")
+  exit(1) unless have_func("LoadLibrary")
+end
+
+if have_header("stdbool.h")
+  stdbool = "stdbool.h"
+else
+  stdbool = nil
+end
+
+if have_header("stdint.h")
+  stdint = "stdint.h"
+elsif have_header("sys/types.h")
+  stdint = "sys/types.h"
+else
+  stdint = nil
+end
+
+have_type("bool", stdbool)
+unless have_type("u_int8_t", stdint)
+  have_type("uint8_t",stdint)
+end
+unless have_type("u_int16_t", stdint)
+  have_type("uint16_t",stdint)
+end
+have_type("int32_t", stdint)
+unless have_type("u_int32_t", stdint)
+  have_type("uint32_t",stdint)
+end
+have_type("int64_t", stdint)
+unless have_type("u_int64_t", stdint)
+  have_type("uint64_t", stdint)
+end
+have_func("exp10")
+
+have_var("rb_cComplex")
+have_func("rb_thread_call_without_gvl")
+
+create_header('include/cumo/extconf.h')
+$extconf_h = nil # nvcc does not support #include RUBY_EXTCONF_H
+
+create_depend
+
+HEADER_DIRS = (ENV['CPATH'] || '').split(':')
+LIB_DIRS = (ENV['LIBRARY_PATH'] || '').split(':')
+dir_config('cumo', HEADER_DIRS, LIB_DIRS)
+
+have_library('cuda')
+have_library('cudart')
+have_library('nvrtc')
+have_library('cublas')
+# have_library('cusolver')
+# have_library('curand')
+
+create_makefile('cumo')

data/ext/cumo/include/cumo.h

@@ -0,0 +1,25 @@
+#ifndef CUMO_H
+#define CUMO_H
+
+#include "cumo/narray.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+#define CUMO_VERSION "0.1.0"
+#define CUMO_VERSION_CODE 10
+
+bool cumo_compatible_mode_enabled_p();
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+
+#endif /* ifndef CUMO_H */

data/ext/cumo/include/cumo/compat.h

@@ -0,0 +1,23 @@
+#ifndef CUMO_COMPAT_H
+#define CUMO_COMPAT_H
+
+#if !defined RSTRING_LEN
+#define RSTRING_LEN(a) RSTRING(a)->len
+#endif
+#if !defined RSTRING_PTR
+#define RSTRING_PTR(a) RSTRING(a)->ptr
+#endif
+#if !defined RARRAY_LEN
+#define RARRAY_LEN(a) RARRAY(a)->len
+#endif
+#if !defined RARRAY_PTR
+#define RARRAY_PTR(a) RARRAY(a)->ptr
+#endif
+#if !defined RARRAY_AREF
+#define RARRAY_AREF(a,i) RARRAY_PTR(a)[i]
+#endif
+#if !defined RARRAY_ASET
+#define RARRAY_ASET(a,i,v) (RARRAY_PTR(a)[i] = v)
+#endif
+
+#endif /* ifndef CUMO_COMPAT_H */

data/ext/cumo/include/cumo/cuda/cublas.h

@@ -0,0 +1,153 @@
+#ifndef CUMO_CUDA_CUBLAS_H
+#define CUMO_CUDA_CUBLAS_H
+
+#include <ruby.h>
+#include "cublas_v2.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+#define option_value cumo_cublas_option_value
+extern VALUE cumo_cublas_option_value(VALUE value, VALUE default_value);
+
+//#define option_order cumo_cublas_option_order
+//extern enum CBLAS_ORDER cumo_cublas_option_order(VALUE order);
+
+#define option_trans cumo_cublas_option_trans
+extern cublasOperation_t cumo_cublas_option_trans(VALUE trans);
+
+#define option_uplo cumo_cublas_option_uplo
+extern cublasFillMode_t cumo_cublas_option_uplo(VALUE uplo);
+
+#define option_diag cumo_cublas_option_diag
+extern cublasDiagType_t cumo_cublas_option_diag(VALUE diag);
+
+#define option_side cumo_cublas_option_side
+extern cublasSideMode_t cumo_cublas_option_side(VALUE side);
+
+//#define check_func cumo_cublas_check_func
+//extern void cumo_cublas_check_func(void **func, const char *name);
+
+// TODO: Check if a and b are row_major?
+#define SWAP_IFROW(a,b,tmp)                                       \
+    {(tmp)=(a);(a)=(b);(b)=(tmp);}
+
+#define SWAP_IFTR(trans,a,b,tmp)                                  \
+    { if ((trans)!=CUBLAS_OP_N)                                   \
+            {(tmp)=(a);(a)=(b);(b)=(tmp);}                        \
+    }
+
+/*
+//#define SWAP_IFCOLTR(order,trans,a,b,tmp)                       \
+//    { if (((order)==CblasRowMajor && (trans)!=CblasNoTrans) ||  \
+//          ((order)!=CblasRowMajor && (trans)==CblasNoTrans))    \
+//            {(tmp)=(a);(a)=(b);(b)=(tmp);}                      \
+//    }
+
+//#define SWAP_IFCOL(order,a,b,tmp)                               \
+//    { if ((order)==CblasColMajor) {(tmp)=(a);(a)=(b);(b)=(tmp);} }
+//
+//#define SWAP_IFROW(order,a,b,tmp)                               \
+//    { if ((order)==CblasRowMajor) {(tmp)=(a);(a)=(b);(b)=(tmp);} }
+//
+//#define SWAP_IFCOLTR(order,trans,a,b,tmp)                       \
+//    { if (((order)==CblasRowMajor && (trans)!=CblasNoTrans) ||  \
+//          ((order)!=CblasRowMajor && (trans)==CblasNoTrans))    \
+//            {(tmp)=(a);(a)=(b);(b)=(tmp);}                      \
+//    }
+//
+//#define CHECK_FUNC(fptr, fname)                                 \
+//    { if ((fptr)==0) { check_func((void*)(&(fptr)),fname); } }
+*/
+
+#define ROW_SIZE(na) ((na)->shape[(na)->ndim-2])
+#define COL_SIZE(na) ((na)->shape[(na)->ndim-1])
+
+#define CHECK_NARRAY_TYPE(x,t)                                 \
+    if (CLASS_OF(x)!=(t)) {                                    \
+        rb_raise(rb_eTypeError,"invalid NArray type (class)"); \
+    }
+
+// Error Class ??
+#define CHECK_DIM_GE(na,nd)                                     \
+    if ((na)->ndim<(nd)) {                                      \
+        rb_raise(nary_eShapeError,                              \
+                 "n-dimension=%d, but >=%d is expected",        \
+                 (na)->ndim, (nd));                             \
+    }
+
+#define CHECK_DIM_EQ(na1,nd)                                    \
+    if ((na1)->ndim != (nd)) {                                  \
+        rb_raise(nary_eShapeError,                              \
+                 "dimention mismatch: %d != %d",                \
+                 (na1)->ndim, (nd));                            \
+    }
+
+#define CHECK_SQUARE(name,na)                                           \
+    if ((na)->shape[(na)->ndim-1] != (na)->shape[(na)->ndim-2]) {       \
+        rb_raise(nary_eShapeError,"%s is not square matrix",name);      \
+    }
+
+#define CHECK_SIZE_GE(na,sz)                                    \
+    if ((na)->size < (size_t)(sz)) {                            \
+        rb_raise(nary_eShapeError,                              \
+                 "NArray size must be >= %"SZF"u",(size_t)(sz));\
+    }
+#define CHECK_NON_EMPTY(na)                                     \
+    if ((na)->size==0) {                                        \
+        rb_raise(nary_eShapeError,"empty NArray");              \
+    }
+
+#define CHECK_SIZE_EQ(n,m)                                      \
+    if ((n)!=(m)) {                                             \
+        rb_raise(nary_eShapeError,                              \
+                 "size mismatch: %"SZF"d != %"SZF"d",           \
+                 (size_t)(n),(size_t)(m));                      \
+    }
+
+#define CHECK_SAME_SHAPE(na1,na2)                                \
+    {   int i;                                                   \
+        CHECK_DIM_EQ(na1,na2->ndim);                             \
+        for (i=0; i<na1->ndim; i++) {                            \
+            CHECK_SIZE_EQ(na1->shape[i],na2->shape[i]);          \
+        }                                                        \
+    }
+
+#define CHECK_INT_EQ(sm,m,sn,n)                          \
+    if ((m) != (n)) {                                    \
+        rb_raise(nary_eShapeError,                       \
+                 "%s must be == %s: %s=%d %s=%d",        \
+                 sm,sn,sm,m,sn,n);                       \
+    }
+
+// Error Class ??
+#define CHECK_LEADING_GE(sld,ld,sn,n)                    \
+    if ((ld) < (n)) {                                    \
+        rb_raise(nary_eShapeError,                       \
+                 "%s must be >= max(%s,1): %s=%d %s=%d", \
+                 sld,sn,sld,ld,sn,n);                    \
+    }
+
+#define COPY_OR_CAST_TO(a,T)                            \
+    {                                                   \
+        if (CLASS_OF(a) == (T)) {                       \
+            if (!TEST_INPLACE(a)) {                     \
+                a = na_copy(a);                         \
+            }                                           \
+        } else {                                        \
+            a = rb_funcall(T,rb_intern("cast"),1,a);    \
+        }                                               \
+    }
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+
+#endif /* ifndef CUMO_CUDA_CUBLAS_H */

data/ext/cumo/include/cumo/cuda/cumo_thrust.hpp

@@ -0,0 +1,187 @@
+#ifndef CUMO_CUDA_THRUST_H
+#define CUMO_CUDA_THRUST_H
+
+#include <thrust/device_ptr.h>
+#include <thrust/device_vector.h>
+#include <thrust/extrema.h>
+#include <thrust/functional.h>
+#include <thrust/inner_product.h>
+#include <thrust/iterator/counting_iterator.h>
+#include <thrust/iterator/transform_iterator.h>
+#include <thrust/iterator/permutation_iterator.h>
+#include <thrust/reduce.h>
+#include <thrust/system/cuda/execution_policy.h>
+#include <thrust/transform_reduce.h>
+
+// this example illustrates how to make strided access to a range of values
+// examples:
+//   strided_range([0, 1, 2, 3, 4, 5, 6], 1) -> [0, 1, 2, 3, 4, 5, 6]
+//   strided_range([0, 1, 2, 3, 4, 5, 6], 2) -> [0, 2, 4, 6]
+//   strided_range([0, 1, 2, 3, 4, 5, 6], 3) -> [0, 3, 6]
+//   ...
+// ref. https://github.com/thrust/thrust/blob/master/examples/strided_range.cu (Apache License)
+
+template <typename Iterator>
+class cumo_thrust_strided_range
+{
+    public:
+
+    typedef typename thrust::iterator_difference<Iterator>::type difference_type;
+
+    struct stride_functor : public thrust::unary_function<difference_type,difference_type>
+    {
+        difference_type stride;
+
+        stride_functor(difference_type stride)
+            : stride(stride) {}
+
+        __host__ __device__
+        difference_type operator()(const difference_type& i) const
+        {
+            return stride * i;
+        }
+    };
+
+    typedef typename thrust::counting_iterator<difference_type>                   CountingIterator;
+    typedef typename thrust::transform_iterator<stride_functor, CountingIterator> TransformIterator;
+    typedef typename thrust::permutation_iterator<Iterator,TransformIterator>     PermutationIterator;
+
+    // type of the strided_range iterator
+    typedef PermutationIterator iterator;
+
+    // construct strided_range for the range [first,last)
+    cumo_thrust_strided_range(Iterator first, Iterator last, difference_type stride)
+        : first(first), last(last), stride(stride) {}
+
+    iterator begin(void) const
+    {
+        return PermutationIterator(first, TransformIterator(CountingIterator(0), stride_functor(stride)));
+    }
+
+    iterator end(void) const
+    {
+        return begin() + ((last - first) + (stride - 1)) / stride;
+    }
+
+    protected:
+    Iterator first;
+    Iterator last;
+    difference_type stride;
+};
+
+
+// compute minimum and maximum values in a single reduction
+// ref. https://github.com/thrust/thrust/blob/master/examples/minmax.cu (Apache License)
+
+// cumo_thrust_minmax_pair stores the minimum and maximum
+// values that have been encountered so far
+template <typename T>
+struct cumo_thrust_minmax_pair
+{
+    T min_val;
+    T max_val;
+};
+
+// cumo_thrust_minmax_unary_op is a functor that takes in a value x and
+// returns a cumo_thrust_minmax_pair whose minimum and maximum values
+// are initialized to x.
+template <typename T>
+struct cumo_thrust_minmax_unary_op : public thrust::unary_function< T, cumo_thrust_minmax_pair<T> >
+{
+    __host__ __device__ cumo_thrust_minmax_pair<T> operator()(const T& x) const
+    {
+        cumo_thrust_minmax_pair<T> result;
+        result.min_val = x;
+        result.max_val = x;
+        return result;
+    }
+};
+
+// cumo_thrust_minmax_binary_op is a functor that accepts two cumo_thrust_minmax_pair
+// structs and returns a new cumo_thrust_minmax_pair whose minimum and
+// maximum values are the min() and max() respectively of
+// the minimums and maximums of the input pairs
+template <typename T>
+struct cumo_thrust_minmax_binary_op : public thrust::binary_function< cumo_thrust_minmax_pair<T>, cumo_thrust_minmax_pair<T>, cumo_thrust_minmax_pair<T> >
+{
+    __host__ __device__ cumo_thrust_minmax_pair<T> operator()(const cumo_thrust_minmax_pair<T>& x, const cumo_thrust_minmax_pair<T>& y) const
+    {
+        cumo_thrust_minmax_pair<T> result;
+        result.min_val = thrust::min(x.min_val, y.min_val);
+        result.max_val = thrust::max(x.max_val, y.max_val);
+        return result;
+    }
+};
+
+// ref. https://github.com/thrust/thrust/blob/master/examples/summary_statistics.cu
+
+// structure used to accumulate the moments and other
+// statistical properties encountered so far.
+template <typename T>
+struct cumo_thrust_variance_data
+{
+    T n;
+    T mean;
+    T M2;
+
+    // initialize to the identity element
+    void initialize()
+    {
+        n = mean = M2 = 0;
+    }
+
+    __host__ __device__ T variance()   { return M2 / (n - 1); }
+    __host__ __device__ T variance_n() { return M2 / n; }
+};
+
+// stats_unary_op is a functor that takes in a value x and
+// returns a variace_data whose mean value is initialized to x.
+template <typename T>
+struct cumo_thrust_variance_unary_op
+{
+    __host__ __device__
+    cumo_thrust_variance_data<T> operator()(const T& x) const
+    {
+         cumo_thrust_variance_data<T> result;
+         result.n    = 1;
+         result.mean = x;
+         result.M2   = 0;
+
+         return result;
+    }
+};
+
+// cumo_thrust_variance_binary_op is a functor that accepts two cumo_thrust_variance_data
+// structs and returns a new cumo_thrust_variance_data which are an
+// approximation to the cumo_thrust_variance for
+// all values that have been agregated so far
+template <typename T>
+struct cumo_thrust_variance_binary_op
+    : public thrust::binary_function<const cumo_thrust_variance_data<T>&,
+                                     const cumo_thrust_variance_data<T>&,
+                                           cumo_thrust_variance_data<T> >
+{
+    __host__ __device__
+    cumo_thrust_variance_data<T> operator()(const cumo_thrust_variance_data<T>& x, const cumo_thrust_variance_data <T>& y) const
+    {
+        cumo_thrust_variance_data<T> result;
+
+        // precompute some common subexpressions
+        T n  = x.n + y.n;
+
+        T delta  = y.mean - x.mean;
+        T delta2 = delta  * delta;
+
+        //Basic number of samples (n)
+        result.n   = n;
+
+        result.mean = x.mean + delta * y.n / n;
+
+        result.M2  = x.M2 + y.M2;
+        result.M2 += delta2 * x.n * y.n / n;
+
+        return result;
+    }
+};
+
+#endif /* ifndef CUMO_CUDA_THRUST_H */