cumo 0.1.0

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

@@ -0,0 +1,79 @@
+#ifndef CUMO_CUDA_THRUST_COMPLEX_H
+#define CUMO_CUDA_THRUST_COMPLEX_H
+
+#include "cumo/types/complex_kernel.h"
+#include "cumo/cuda/cumo_thrust.hpp"
+
+// 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, typename R>
+struct cumo_thrust_complex_variance_data
+{
+    R n;
+    T mean;
+    R M2;
+
+    // initialize to the identity element
+    void initialize()
+    {
+        n = M2 = 0;
+        mean = c_zero();
+    }
+
+    __host__ __device__ R variance()   { return M2 / (n - 1); }
+    __host__ __device__ R 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, typename R>
+struct cumo_thrust_complex_variance_unary_op
+{
+    __host__ __device__
+    cumo_thrust_complex_variance_data<T,R> operator()(const T& x) const
+    {
+         cumo_thrust_complex_variance_data<T,R> 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, typename R>
+struct cumo_thrust_complex_variance_binary_op
+    : public thrust::binary_function<const cumo_thrust_complex_variance_data<T,R>&,
+                                     const cumo_thrust_complex_variance_data<T,R>&,
+                                           cumo_thrust_complex_variance_data<T,R> >
+{
+    __host__ __device__
+    cumo_thrust_complex_variance_data<T,R> operator()(const cumo_thrust_complex_variance_data<T,R>& x, const cumo_thrust_complex_variance_data<T,R>& y) const
+    {
+        cumo_thrust_complex_variance_data<T,R> result;
+
+        // precompute some common subexpressions
+        R n  = x.n + y.n;
+
+        T delta = c_sub(y.mean, x.mean);
+        R delta2 = c_abs_square(delta);
+
+        //Basic number of samples (n)
+        result.n = n;
+
+        result.mean = c_add(x.mean, c_mul_r(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_COMPLEX_H */

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

@@ -0,0 +1,22 @@
+#ifndef CUMO_CUDA_DRIVER_H
+#define CUMO_CUDA_DRIVER_H
+#include <cuda.h>
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+extern VALUE cumo_cuda_eDriverError;
+extern VALUE cumo_cuda_mDriver;
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+
+#endif /* ifndef CUMO_CUDA_DRIVER_H */

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

@@ -0,0 +1,28 @@
+#ifndef CUMO_CUDA_MEMORY_POOL_H
+#define CUMO_CUDA_MEMORY_POOL_H
+
+#include "cumo/narray.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+extern VALUE cumo_cuda_eOutOfMemoryError;
+
+char*
+cumo_cuda_runtime_malloc(size_t size);
+
+void
+cumo_cuda_runtime_free(char *ptr);
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+
+#endif /* ifndef CUMO_CUDA_MEMORY_POOL_H */

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

@@ -0,0 +1,22 @@
+#ifndef CUMO_CUDA_NVRTC_H
+#define CUMO_CUDA_NVRTC_H
+#include <nvrtc.h>
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+extern VALUE cumo_cuda_eNVRTCError;
+extern VALUE cumo_cuda_mNVRTC;
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+
+#endif /* ifndef CUMO_CUDA_NVRTC_H */

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

@@ -0,0 +1,40 @@
+#ifndef CUMO_CUDA_RUNTIME_H
+#define CUMO_CUDA_RUNTIME_H
+
+#include "cumo/narray.h"
+#include <cuda_runtime.h>
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+extern VALUE cumo_cuda_eRuntimeError;
+
+static inline void
+cumo_cuda_runtime_check_status(cudaError_t status)
+{
+    if (status != 0) {
+        rb_raise(cumo_cuda_eRuntimeError, "%s (error=%d)", cudaGetErrorString(status), status);
+    }
+}
+
+static inline bool
+cumo_cuda_runtime_is_device_memory(void* ptr)
+{
+    struct cudaPointerAttributes attrs;
+    cudaError_t status = cudaPointerGetAttributes(&attrs, ptr);
+    cudaGetLastError(); // reset last error to success
+    return (status != cudaErrorInvalidValue);
+}
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+
+#endif /* ifndef CUMO_CUDA_RUNTIME_H */

data/ext/cumo/include/cumo/indexer.h

@@ -0,0 +1,238 @@
+#ifndef CUMO_INDEXER_H
+#define CUMO_INDEXER_H
+
+/* Add cumo_ prefix */
+#define na_indexer_t cumo_na_indexer_t
+#define na_iarray_t cumo_na_iarray_t
+#define na_reduction_arg_t cumo_na_reduction_arg_t
+
+#ifndef __CUDACC__
+#include "cumo/narray.h"
+#include "cumo/ndloop.h"
+#else
+#include "cumo/narray_kernel.h"
+#endif
+
+/* A structure to get indices for each dimension.
+ *
+ * Note that shapes of each argument NArray are typically equivalent, and
+ * thus indexer would point the same indicies for all NArrays.
+ */
+typedef struct {
+    unsigned char ndim;               // # of dimensions
+    size_t total_size;                // # of total elements
+    size_t shape[NA_MAX_DIMENSION];   // # of elements for each dimension
+    uint64_t index[NA_MAX_DIMENSION]; // indicies for each dimension
+    uint64_t raw_index;
+} na_indexer_t;
+
+/* A structure to get data address with indexer.
+ *
+ * Note that strides would be different for each NArray although indexer points same indicies.
+ */
+typedef struct {
+    char* ptr;
+    ssize_t step[NA_MAX_DIMENSION]; // or strides
+} na_iarray_t;
+
+typedef struct {
+    na_iarray_t in;
+    na_iarray_t out;
+    na_indexer_t in_indexer;
+    na_indexer_t out_indexer;
+    na_indexer_t reduce_indexer;
+} na_reduction_arg_t;
+
+#ifndef __CUDACC__
+extern int na_debug_flag;  // narray.c
+
+static void
+print_na_indexer_t(na_indexer_t* indexer)
+{
+    printf("na_indexer_t = 0x%"SZF"x {\n", (size_t)indexer);
+    printf("  ndim = %d\n", indexer->ndim);
+    printf("  total_size = %ld\n", indexer->total_size);
+    printf("  shape = 0x%"SZF"x\n", (size_t)indexer->shape);
+    for (int i = 0; i < indexer->ndim; ++i) {
+        printf("  shape[%d] = %ld\n", i, indexer->shape[i]);
+    }
+    printf("}\n");
+}
+
+static void
+print_na_iarray_t(na_iarray_t* iarray, unsigned char ndim)
+{
+    printf("na_iarray_t = 0x%"SZF"x {\n", (size_t)iarray);
+    printf("  ptr = 0x%"SZF"x\n", (size_t)iarray->ptr);
+    printf("  step = 0x%"SZF"x\n", (size_t)iarray->step);
+    for (int i = 0; i < ndim; ++i) {
+        printf("  step[%d] = %ld\n", i, iarray->step[i]);
+    }
+    printf("}\n");
+}
+
+static void
+print_na_reduction_arg_t(na_reduction_arg_t* arg)
+{
+    printf("na_reduction_arg_t = 0x%"SZF"x {\n", (size_t)arg);
+    printf("--in--\n");
+    print_na_iarray_t(&arg->in, arg->in_indexer.ndim);
+    printf("--out--\n");
+    print_na_iarray_t(&arg->out, arg->out_indexer.ndim);
+    printf("--in_indexer--\n");
+    print_na_indexer_t(&arg->in_indexer);
+    printf("--out_indexer--\n");
+    print_na_indexer_t(&arg->out_indexer);
+    printf("--reduce_indexer--\n");
+    print_na_indexer_t(&arg->reduce_indexer);
+    printf("}\n");
+}
+
+// Note that you, then, have to call na_indexer_set to create index[]
+static na_indexer_t
+na_make_indexer(na_loop_args_t* arg)
+{
+    na_indexer_t indexer;
+    indexer.ndim = arg->ndim;
+    indexer.total_size = 1;
+    for (int i = 0; i < arg->ndim; ++i) {
+        indexer.shape[i] = arg->shape[i];
+        indexer.total_size *= arg->shape[i];
+    }
+    return indexer;
+}
+
+static na_iarray_t
+na_make_iarray_given_ndim(na_loop_args_t* arg, int ndim)
+{
+    na_iarray_t iarray;
+    iarray.ptr = arg->ptr + arg->iter[0].pos;
+    for (int idim = ndim; --idim >= 0;) {
+        iarray.step[idim] = arg->iter[idim].step;
+    }
+    return iarray;
+}
+
+static na_iarray_t
+na_make_iarray(na_loop_args_t* arg)
+{
+    return na_make_iarray_given_ndim(arg, arg->ndim);
+}
+
+static na_reduction_arg_t
+na_make_reduction_arg(na_loop_t* lp_user)
+{
+    na_reduction_arg_t arg;
+    int i;
+    int in_ndim = lp_user->args[0].ndim;
+
+    // in shape = (2, 3, 4, 5, 6)
+    // axis = (1, 3)
+    // out shape = (2, 4, 6)
+    // reduce shape = (3, 5)
+
+    arg.in = na_make_iarray(&lp_user->args[0]);
+    arg.in_indexer = na_make_indexer(&lp_user->args[0]);
+
+    arg.reduce_indexer.ndim = 0;
+    arg.reduce_indexer.total_size = 1;
+    arg.out_indexer.ndim = 0;
+    arg.out_indexer.total_size = 1;
+    for (i = 0; i < in_ndim; ++i) {
+        if (na_test_reduce(lp_user->reduce, i)) {
+            arg.reduce_indexer.shape[arg.reduce_indexer.ndim] = arg.in_indexer.shape[i];
+            arg.reduce_indexer.total_size *= arg.in_indexer.shape[i];
+            ++arg.reduce_indexer.ndim;
+        } else {
+            arg.out_indexer.shape[arg.out_indexer.ndim] = arg.in_indexer.shape[i];
+            arg.out_indexer.total_size *= arg.in_indexer.shape[i];
+            ++arg.out_indexer.ndim;
+        }
+    }
+    arg.out = na_make_iarray_given_ndim(&lp_user->args[1], arg.out_indexer.ndim);
+
+    if (na_debug_flag) {
+        print_na_reduction_arg_t(&arg);
+    }
+
+    assert(arg.reduce_indexer.ndim == lp_user->reduce_dim);
+    assert(arg.in_indexer.ndim == arg.reduce_indexer.ndim + arg.out_indexer.ndim);
+
+    return arg;
+}
+
+#endif  // #ifndef __CUDACC__
+
+#define CUMO_NA_INDEXER_OPTIMIZED_NDIM 4
+
+#ifdef __CUDACC__
+
+__host__ __device__
+static inline void
+cumo_na_indexer_set_dim(na_indexer_t* indexer, uint64_t i) {
+    indexer->raw_index = i;
+    for (int j = indexer->ndim; --j >= 0;) {
+        indexer->index[j] = i % indexer->shape[j];
+        i /= indexer->shape[j];
+    }
+}
+
+// Let compiler optimize
+#define CUMO_NA_INDEXER_SET(NDIM) \
+__host__ __device__ \
+static inline void \
+cumo_na_indexer_set_dim##NDIM(na_indexer_t* indexer, uint64_t i) { \
+    indexer->raw_index = i; \
+    for (int j = NDIM; --j >= 0;) { \
+        indexer->index[j] = i % indexer->shape[j]; \
+        i /= indexer->shape[j]; \
+    } \
+}
+
+CUMO_NA_INDEXER_SET(4)
+CUMO_NA_INDEXER_SET(3)
+CUMO_NA_INDEXER_SET(2)
+CUMO_NA_INDEXER_SET(0)
+
+__host__ __device__
+static inline void
+cumo_na_indexer_set_dim1(na_indexer_t* indexer, uint64_t i) {
+    indexer->raw_index = i;
+}
+
+__host__ __device__
+static inline char*
+cumo_na_iarray_at_dim(na_iarray_t* iarray, na_indexer_t* indexer) {
+    char* ptr = iarray->ptr;
+    for (int idim = 0; idim < indexer->ndim; ++idim) {
+        ptr += iarray->step[idim] * indexer->index[idim];
+    }
+    return ptr;
+}
+
+// Let compiler optimize
+#define CUMO_NA_IARRAY_AT(NDIM) \
+__host__ __device__ \
+static inline char* \
+cumo_na_iarray_at_dim##NDIM(na_iarray_t* iarray, na_indexer_t* indexer) { \
+    char* ptr = iarray->ptr; \
+    for (int idim = 0; idim < NDIM; ++idim) { \
+        ptr += iarray->step[idim] * indexer->index[idim]; \
+    } \
+    return ptr; \
+}
+
+CUMO_NA_IARRAY_AT(4)
+CUMO_NA_IARRAY_AT(3)
+CUMO_NA_IARRAY_AT(2)
+CUMO_NA_IARRAY_AT(0)
+
+__host__ __device__
+static inline char*
+cumo_na_iarray_at_dim1(na_iarray_t* iarray, na_indexer_t* indexer) {
+    return iarray->ptr + iarray->step[0] * indexer->raw_index;
+}
+
+#endif // #ifdef __CUDACC__
+
+#endif // CUMO_INDEXER_H

data/ext/cumo/include/cumo/intern.h

@@ -0,0 +1,142 @@
+#ifndef CUMO_INTERN_H
+#define CUMO_INTERN_H
+
+void cumo_debug_breakpoint(void);
+
+/* Add cumo_ prefix to avoid C symbol collisions with Numo without modifying C implementations */
+
+#define rb_narray_new cumo_nary_new
+#define nary_new cumo_nary_new
+VALUE cumo_nary_new(VALUE elem, int ndim, size_t *shape);
+#define rb_narray_view_new cumo_nary_view_new
+#define nary_view_new cumo_nary_view_new
+VALUE cumo_nary_view_new(VALUE elem, int ndim, size_t *shape);
+#define rb_narray_debug_info cumo_nary_debug_info
+#define nary_debug_info cumo_nary_debug_info
+VALUE cumo_nary_debug_info(VALUE);
+
+#define na_make_view cumo_nary_make_view
+VALUE cumo_nary_make_view(VALUE self);
+
+#define na_s_allocate cumo_nary_s_allocate
+VALUE cumo_nary_s_allocate(VALUE klass);
+#define na_s_allocate_view cumo_nary_s_allocate_view
+VALUE cumo_nary_s_allocate_view(VALUE klass);
+#define na_s_new_like cumo_nary_s_new_like
+VALUE cumo_nary_s_new_like(VALUE type, VALUE obj);
+
+#define na_alloc_shape cumo_na_alloc_shape
+void cumo_na_alloc_shape(narray_t *na, int ndim);
+#define na_array_to_internal_shape cumo_na_array_to_internal_shape
+void cumo_na_array_to_internal_shape(VALUE self, VALUE ary, size_t *shape);
+#define na_index_arg_to_internal_order cumo_na_index_arg_to_internal_order
+void cumo_na_index_arg_to_internal_order(int argc, VALUE *argv, VALUE self);
+#define na_setup_shape cumo_na_setup_shape
+void cumo_na_setup_shape(narray_t *na, int ndim, size_t *shape);
+
+#define na_get_elmsz cumo_nary_element_stride
+#define nary_element_stride cumo_nary_element_stride
+//#define na_element_stride cumo_nary_element_stride
+unsigned int cumo_nary_element_stride(VALUE nary);
+#define na_dtype_elmsz cumo_nary_dtype_element_stride
+size_t cumo_nary_dtype_element_stride(VALUE klass);
+
+#define na_get_pointer cumo_nary_get_pointer
+char *cumo_nary_get_pointer(VALUE);
+#define na_get_pointer_for_write cumo_nary_get_pointer_for_write
+char *cumo_nary_get_pointer_for_write(VALUE);
+#define na_get_pointer_for_read cumo_nary_get_pointer_for_read
+char *cumo_nary_get_pointer_for_read(VALUE);
+#define na_get_pointer_for_read_write cumo_nary_get_pointer_for_read_write
+char *cumo_nary_get_pointer_for_read_write(VALUE);
+#define na_get_offset cumo_nary_get_offset
+size_t cumo_nary_get_offset(VALUE self);
+
+#define na_copy_flags cumo_nary_copy_flags
+void cumo_nary_copy_flags(VALUE src, VALUE dst);
+
+#define na_check_ladder cumo_nary_check_ladder
+VALUE cumo_nary_check_ladder(VALUE self, int start_dim);
+#define na_check_contiguous cumo_nary_check_contiguous
+VALUE cumo_nary_check_contiguous(VALUE self);
+
+#define na_flatten_dim cumo_nary_flatten_dim
+VALUE cumo_nary_flatten_dim(VALUE self, int sd);
+
+#define na_flatten cumo_nary_flatten
+VALUE cumo_nary_flatten(VALUE);
+
+#define na_copy cumo_nary_dup
+VALUE cumo_nary_dup(VALUE);
+
+#define na_store cumo_nary_store
+VALUE cumo_nary_store(VALUE self, VALUE src);
+
+#define na_upcast cumo_na_upcast
+VALUE cumo_na_upcast(VALUE type1, VALUE type2);
+
+#define na_release_lock cumo_na_release_lock
+void cumo_na_release_lock(VALUE); // currently do nothing
+
+// used in reduce methods
+#define nary_reduce_dimension cumo_nary_reduce_dimension
+#define na_reduce_dimension cumo_nary_reduce_dimension
+VALUE cumo_nary_reduce_dimension(int argc, VALUE *argv, int naryc, VALUE *naryv,
+                            ndfunc_t *ndf, na_iter_func_t nan_iter);
+
+#define nary_reduce_options cumo_nary_reduce_options
+#define na_reduce_options cumo_nary_reduce_options
+VALUE cumo_nary_reduce_options(VALUE axes, VALUE *opts, int naryc, VALUE *naryv,
+                          ndfunc_t *ndf);
+
+// ndloop
+#define na_ndloop cumo_na_ndloop
+VALUE cumo_na_ndloop(ndfunc_t *nf, int argc, ...);
+#define na_ndloop2 cumo_na_ndloop2
+VALUE cumo_na_ndloop2(ndfunc_t *nf, VALUE args);
+#define na_ndloop3 cumo_na_ndloop3
+VALUE cumo_na_ndloop3(ndfunc_t *nf, void *ptr, int argc, ...);
+#define na_ndloop4 cumo_na_ndloop4
+VALUE cumo_na_ndloop4(ndfunc_t *nf, void *ptr, VALUE args);
+
+#define na_ndloop_cast_narray_to_rarray cumo_na_ndloop_cast_narray_to_rarray
+VALUE cumo_na_ndloop_cast_narray_to_rarray(ndfunc_t *nf, VALUE nary, VALUE fmt);
+#define na_ndloop_store_rarray cumo_na_ndloop_store_rarray
+VALUE cumo_na_ndloop_store_rarray(ndfunc_t *nf, VALUE nary, VALUE rary);
+#define na_ndloop_store_rarray2 cumo_na_ndloop_store_rarray2
+VALUE cumo_na_ndloop_store_rarray2(ndfunc_t *nf, VALUE nary, VALUE rary, VALUE opt);
+#define na_ndloop_inspect cumo_na_ndloop_inspect
+VALUE cumo_na_ndloop_inspect(VALUE nary, na_text_func_t func, VALUE opt);
+#define na_ndloop_with_index cumo_na_ndloop_with_index
+VALUE cumo_na_ndloop_with_index(ndfunc_t *nf, int argc, ...);
+
+#define na_info_str cumo_nary_info_str
+VALUE cumo_nary_info_str(VALUE);
+
+#define na_test_reduce cumo_nary_test_reduce
+bool cumo_nary_test_reduce(VALUE reduce, int dim);
+
+#define nary_step_array_index cumo_nary_step_array_index
+void cumo_nary_step_array_index(VALUE self, size_t ary_size, size_t *plen, ssize_t *pbeg, ssize_t *pstep);
+#define nary_step_sequence cumo_nary_step_sequence
+void cumo_nary_step_sequence(VALUE self, size_t *plen, double *pbeg, double *pstep);
+
+// used in aref, aset
+#define na_get_result_dimension cumo_nary_get_result_dimension
+int cumo_nary_get_result_dimension(VALUE self, int argc, VALUE *argv, ssize_t stride, size_t *pos_idx);
+#define na_aref_main cumo_nary_aref_main
+VALUE cumo_nary_aref_main(int nidx, VALUE *idx, VALUE self, int keep_dim, int result_nd, size_t pos);
+
+// defined in array, used in math
+#define na_ary_composition_dtype cumo_na_ary_composition_dtype
+VALUE cumo_na_ary_composition_dtype(VALUE ary);
+
+#include "ruby/version.h"
+
+#if RUBY_API_VERSION_CODE == 20100 // 2.1.0
+int rb_get_kwargs(VALUE keyword_hash, const ID *table, int required, int optional, VALUE *);
+VALUE rb_extract_keywords(VALUE *orighash);
+#endif
+
+
+#endif /* ifndef CUMO_INTERN_H */