cumo 0.1.0

data/ext/cumo/narray/gen/tmpl/format.c

@@ -0,0 +1,62 @@
+static VALUE
+format_<%=type_name%>(VALUE fmt, dtype* x)
+{
+    // fix-me
+    char s[48];
+    int n;
+
+    if (NIL_P(fmt)) {
+        n = m_sprintf(s,*x);
+        return rb_str_new(s,n);
+    }
+    return rb_funcall(fmt, '%', 1, m_data_to_num(*x));
+}
+
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t  i;
+    char   *p1, *p2;
+    ssize_t s1, s2;
+    size_t *idx1;
+    dtype *x;
+    VALUE y;
+    VALUE fmt = lp->option;
+    INIT_COUNTER(lp, i);
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    INIT_PTR(lp, 1, p2, s2);
+    //SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    if (idx1) {
+        for (; i--;) {
+            x = (dtype*)(p1+*idx1); idx1++;
+            y = format_<%=type_name%>(fmt, x);
+            SET_DATA_STRIDE(p2, s2, VALUE, y);
+        }
+    } else {
+        for (; i--;) {
+            x = (dtype*)p1;         p1+=s1;
+            y = format_<%=type_name%>(fmt, x);
+            SET_DATA_STRIDE(p2, s2, VALUE, y);
+        }
+    }
+}
+
+/*
+  Format elements into strings.
+  @overload <%=name%> format
+  @param [String] format
+  @return [Cumo::RObject] array of formated strings.
+*/
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
+{
+    VALUE fmt=Qnil;
+
+    ndfunc_arg_in_t ain[2] = {{Qnil,0},{sym_option}};
+    ndfunc_arg_out_t aout[1] = {{cumo_cRObject,0}};
+    ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP_NIP, 2, 1, ain, aout };
+
+    rb_scan_args(argc, argv, "01", &fmt);
+    cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
+    return na_ndloop(&ndf, 2, self, fmt);
+}

data/ext/cumo/narray/gen/tmpl/format_to_a.c

@@ -0,0 +1,49 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t  i;
+    char   *p1;
+    ssize_t s1;
+    size_t *idx1;
+    dtype *x;
+    VALUE y;
+    volatile VALUE a;
+    VALUE fmt = lp->option;
+    INIT_COUNTER(lp, i);
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    a = rb_ary_new2(i);
+    rb_ary_push(lp->args[1].value, a);
+    //SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    if (idx1) {
+        for (; i--;) {
+            x = (dtype*)(p1 + *idx1);  idx1++;
+            y = format_<%=type_name%>(fmt, x);
+            rb_ary_push(a,y);
+        }
+    } else {
+        for (; i--;) {
+            x = (dtype*)p1;  p1+=s1;
+            y = format_<%=type_name%>(fmt, x);
+            rb_ary_push(a,y);
+        }
+    }
+}
+
+/*
+  Format elements into strings.
+  @overload <%=name%> format
+  @param [String] format
+  @return [Array] array of formated strings.
+*/
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
+{
+    VALUE fmt=Qnil;
+    ndfunc_arg_in_t ain[3] = {{Qnil,0},{sym_loop_opt},{sym_option}};
+    ndfunc_arg_out_t aout[1] = {{rb_cArray,0}}; // dummy?
+    ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP_NIP, 3, 1, ain, aout };
+
+    rb_scan_args(argc, argv, "01", &fmt);
+    cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
+    return na_ndloop_cast_narray_to_rarray(&ndf, self, fmt);
+}

data/ext/cumo/narray/gen/tmpl/frexp.c

@@ -0,0 +1,38 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t   i;
+    char    *p1, *p2, *p3;
+    ssize_t  s1, s2, s3;
+    dtype    x;
+    int      y;
+    INIT_COUNTER(lp, i);
+    INIT_PTR(lp, 0, p1, s1);
+    INIT_PTR(lp, 1, p2, s2);
+    INIT_PTR(lp, 2, p3, s3);
+    SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("<%=name%>", "<%=type_name%>");
+    for (; i--;) {
+        GET_DATA_STRIDE(p1,s1,dtype,x);
+        x = m_<%=name%>(x,&y);
+        SET_DATA_STRIDE(p2,s2,dtype,x);
+        SET_DATA_STRIDE(p3,s3,int32_t,y);
+    }
+}
+
+/*
+  split the number x into a normalized fraction and an exponent.
+  Returns [mantissa, exponent], where x = mantissa * 2**exponent.
+
+  @overload <%=name%>(x)
+  @param [Cumo::NArray,Numeric]  x
+  @return [Cumo::<%=class_name%>,Cumo::Int32]  mantissa and exponent.
+
+*/
+static VALUE
+<%=c_func(1)%>(VALUE mod, VALUE a1)
+{
+    ndfunc_arg_in_t ain[1] = {{cT,0}};
+    ndfunc_arg_out_t aout[2] = {{cT,0},{cumo_cInt32,0}};
+    ndfunc_t ndf = { <%=c_iter%>, STRIDE_LOOP, 1,2, ain,aout };
+    return na_ndloop(&ndf, 1, a1);
+}

data/ext/cumo/narray/gen/tmpl/gemm.c

@@ -0,0 +1,203 @@
+<%
+  func_prefix =
+    case type_name
+    when 'sfloat'
+      'S'
+    when 'dfloat'
+      'D'
+    when 'scomplex'
+      'C'
+    when 'dcomplex'
+      'Z'
+    end
+  cutype =
+    case type_name
+    when 'sfloat'
+      'float'
+    when 'dfloat'
+      'double'
+    when 'scomplex'
+      'cuComplex'
+    when 'dcomplex'
+      'cuDoubleComplex'
+    end
+%>
+
+#define args_t <%=name%>_args_t
+
+typedef struct {
+  // enum CBLAS_ORDER order; // cuBLAS does not have order (row-major or column-major) option
+  cublasOperation_t transa, transb;
+  cublasSideMode_t side;
+  cublasFillMode_t uplo;
+  cublasDiagType_t diag;
+  dtype alpha, beta;
+  int m, n, k;
+} args_t;
+
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    dtype *a, *b;
+    int    lda, ldb;
+    dtype *c;
+    int    ldc;
+    args_t *g;
+    static cublasHandle_t handle = 0;
+
+    a = (dtype*)NDL_PTR(lp,0);
+    b = (dtype*)NDL_PTR(lp,1);
+    c = (dtype*)NDL_PTR(lp,2);
+    g = (args_t*)(lp->opt_ptr);
+
+    lda = NDL_STEP(lp,0) / sizeof(dtype);
+    ldb = NDL_STEP(lp,1) / sizeof(dtype);
+    ldc = NDL_STEP(lp,2) / sizeof(dtype);
+
+    //printf("transa=%d transb=%d m=%d n=%d k=%d lda=%d ldb=%d ldc=%d\n",g->transa,g->transb,g->m,g->n,g->k,lda,ldb,ldc);
+
+    // Note that cuBLAS uses the column major matrix representation.
+    // We use technic which following site describes:
+    // https://www.christophlassner.de/using-blas-from-c-with-row-major-data.html
+    //
+    // b^T = nxk matrix
+    // a^T = kxm matrix
+    // c^T = nxm matrix
+    // c^T = b^T * a^T
+    //
+    // cublasSgemm(handle,transb,transa,n,m,k,&alpha,b,n,a,k,&beta,c,n);
+
+    // TODO(sonots): Create another handle for another cuda device or cpu thread
+    if (!handle) {
+        cublasCreate(&handle);
+    }
+    cublas<%=func_prefix%>gemm(handle, g->transb, g->transa, g->n, g->m, g->k, (<%=cutype%>*)(&g->alpha), (<%=cutype%>*)b, ldb, (<%=cutype%>*)a, lda, (<%=cutype%>*)(&g->beta), (<%=cutype%>*)c, ldc);
+    // TODO(sonots): Destroy correctly
+    //cublasDestroy(handle);
+}
+
+/*
+<%
+  # ext/numo/linalg/blas/gen/decl.rb
+
+  def mat(v,*a,**h)
+    tp = h[:type] || class_name
+    a.map!{|x| x==:inplace ? "inplace allowed" : x}
+    a.unshift ">=2-dimentional NArray"
+    "@param #{v} [#{tp}]  matrix (#{a.join(', ')})."
+  end
+
+  def opt(v,tp=nil,*a)
+    tp ||= "String or Symbol"
+    case v
+    when /^order$/
+      "@param #{v} [#{tp}]  if 'R': Row-major, if 'C': Column-major. (default='R')"
+    when /^uplo$/
+      "@param #{v} [#{tp}]  if 'U': Upper triangle, if 'L': Lower triangle. (default='U')"
+    when /^side$/
+      "@param #{v} [#{tp}]  if 'L': op(A)\\*B (left-side op), if 'R': B\\*op(A) (right-side op). (default='L')"
+    when /^diag$/
+      "@param #{v} [#{tp}]  if 'U': assumed to be unit triangular, if 'N': not assumed to be unit triangular. (default='U')"
+    when /^trans(\w+)?$/
+      b = a[0] || $1
+      "@param #{v} [#{tp}]  if 'N': Not transpose #{b}, if 'T': Transpose #{b}. (default='N')"
+    when "alpha"
+      "@param #{v} [Float]  (default=1.0)"
+    when "beta"
+      "@param #{v} [Float]  (default=0.0)"
+    else
+      "@param #{v} [#{tp}]  #{a[0]}"
+    end
+  end
+%>
+<%
+ args_v = "a, b, [c, alpha:1, beta:0, transa:'N', transb:'N']"
+ params = [
+   mat("a"),
+   mat("b"),
+   mat("c","optional",:inplace),
+   opt("alpha"),
+   opt("beta"),
+   opt("transa"),
+   opt("transb"),
+ ].select{|x| x}.join("\n  ")
+%>
+  @overload <%=name%>(<%=args_v%>)
+  <%=params%>
+  @return [<%=class_name%>] returns c = alpha\*op( A )\*op( B ) + beta\*C.
+<%=description%>
+*/
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE argv[], VALUE self)
+{
+    VALUE     a=self, b, c=Qnil, alpha, beta;
+    narray_t *na1, *na2;
+    int   ma, ka, kb, nb, tmp;
+    size_t    shape[2];
+    ndfunc_arg_in_t ain[3] = {{cT,2},{cT,2},{OVERWRITE,2}};
+    ndfunc_arg_out_t aout[1] = {{cT,2,shape}};
+    ndfunc_t ndf = {<%=c_iter%>, NO_LOOP, 3, 0, ain, aout};
+
+    args_t g;
+    VALUE kw_hash = Qnil;
+    ID kw_table[4] = {rb_intern("alpha"),rb_intern("beta"),rb_intern("transa"),rb_intern("transb")};
+    VALUE opts[4] = {Qundef,Qundef,Qundef,Qundef};
+
+    rb_scan_args(argc, argv, "11:", &b, &c, &kw_hash);
+    rb_get_kwargs(kw_hash, kw_table, 0, 4, opts);
+    alpha    = option_value(opts[0],Qnil);
+    g.alpha  = RTEST(alpha) ? m_num_to_data(alpha) : m_one;
+    beta     = option_value(opts[1],Qnil);
+    g.beta   = RTEST(beta)  ? m_num_to_data(beta)  : m_zero;
+    g.transa = option_trans(opts[2]);
+    g.transb = option_trans(opts[3]);
+
+    GetNArray(a,na1);
+    GetNArray(b,na2);
+    CHECK_DIM_GE(na1,2);
+    CHECK_DIM_GE(na2,2);
+    ma = ROW_SIZE(na1); // m
+    ka = COL_SIZE(na1); // k
+    kb = ROW_SIZE(na2); // k
+    nb = COL_SIZE(na2); // n
+
+    SWAP_IFTR(g.transa, ma, ka, tmp);
+    SWAP_IFTR(g.transb, kb, nb, tmp);
+    CHECK_INT_EQ("ka",ka,"kb",kb);
+    g.m = ma;
+    g.n = nb;
+    g.k = ka;
+
+    SWAP_IFROW(ma, nb, tmp);
+
+    if (c == Qnil) { // c is not given.
+        ndfunc_arg_in_t ain_init = {sym_init,0};
+        ain[2] = ain_init;
+        ndf.nout = 1;
+        c = INT2FIX(0);
+        shape[0] = nb;
+        shape[1] = ma;
+    } else {
+        narray_t *na3;
+        int nc;
+        COPY_OR_CAST_TO(c,cT);
+        GetNArray(c,na3);
+        CHECK_DIM_GE(na3,2);
+        nc = ROW_SIZE(na3);
+        if (nc < nb) {
+            rb_raise(nary_eShapeError,"nc=%d must be >= nb=%d",nc,nb);
+        }
+        //CHECK_LEADING_GE("ldc",g.ldc,"m",ma);
+    }
+    {
+        VALUE ans = na_ndloop3(&ndf, &g, 3, a, b, c);
+
+        if (ndf.nout == 1) { // c is not given.
+            return ans;
+        } else {
+            return c;
+        }
+    }
+}
+
+#undef args_t

data/ext/cumo/narray/gen/tmpl/init_class.c

@@ -0,0 +1,20 @@
+    /*
+      Document-class: <%= full_class_name %>
+      <%= description %>
+    */
+    cT = rb_define_class_under(<%=ns_var%>, "<%=class_name%>", cNArray);
+
+  <% for x in class_alias %>
+    // alias of <%=class_name%>
+    rb_define_const(<%=ns_var%>, "<%=x%>", <%=type_var%>);
+  <% end %>
+
+    hCast = rb_hash_new();
+    rb_define_const(cT, "UPCAST", hCast);
+    rb_hash_aset(hCast, rb_cArray,   cT);
+    <% for x in upcast %>
+    <%= x %><% end %>
+
+    <% @children.each do |m| %>
+    <%= m.init_def %><% end %>
+    rb_define_singleton_method(cT, "[]", <%=find("cast").c_func%>, -2);

data/ext/cumo/narray/gen/tmpl/init_module.c

@@ -0,0 +1,12 @@
+    /*
+      Document-module: <%= full_module_name %>
+      <%= description %>
+    */
+    <%  if module_var != ns_var %>
+    <%=module_var%> = rb_define_module_under(<%=ns_var%>, "<%=module_name%>");
+    <%  end %>
+    <% @children.each do |m| %>
+    <%= m.init_def %><% end %>
+
+    //  how to do this?
+    //rb_extend_object(cT, mTM);

data/ext/cumo/narray/gen/tmpl/inspect.c

@@ -0,0 +1,21 @@
+static VALUE
+<%=c_iter%>(char *ptr, size_t pos, VALUE fmt)
+{
+<% if is_object %>
+    return rb_inspect(*(VALUE*)(ptr+pos));
+<% else %>
+    return format_<%=type_name%>(fmt, (dtype*)(ptr+pos));
+<% end %>
+}
+
+/*
+  Returns a string containing a human-readable representation of NArray.
+  @overload inspect
+  @return [String]
+*/
+static VALUE
+<%=c_func(0)%>(VALUE ary)
+{
+    cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
+    return na_ndloop_inspect(ary, <%=c_iter%>, Qnil);
+}

data/ext/cumo/narray/gen/tmpl/lib.c

@@ -0,0 +1,50 @@
+/*
+  <%= file_name %>
+  Ruby/Cumo::GSL - GSL wrapper for Ruby/Cumo::NArray
+
+  created on: 2017-03-11
+  Copyright (C) 2017 Masahiro Tanaka
+  Copyright (C) 2018 Naotoshi Seo
+*/
+
+#include <ruby.h>
+#include <assert.h>
+#include "cumo.h"
+#include "cumo/narray.h"
+#include "cumo/template.h"
+#include "SFMT.h"
+#include "cumo/cuda/memory_pool.h"
+#include "cumo/cuda/runtime.h"
+<% unless type_name == 'robject' %>
+#include "cumo/indexer.h"
+<% end %>
+
+#define m_map(x) m_num_to_data(rb_yield(m_data_to_num(x)))
+
+<% id_decl.each do |x| %>
+<%= x %>
+<% end %>
+
+#include <<%="cumo/types/#{type_name}.h"%>>
+
+VALUE cT;
+extern VALUE cRT;
+
+<% children.each do |c|%>
+<%= c.result+"\n\n" %>
+<% end %>
+
+void
+Init_<%=lib_name%>(void)
+{
+    VALUE hCast, <%=ns_var%>;
+
+    <%=ns_var%> = rb_define_module("Cumo");
+
+    <% id_assign.each do |x| %>
+    <%= x %><% end %>
+
+<% children.each do |c| %>
+<%= c.init_def %>
+<% end %>
+}