cumo 0.1.0

data/ext/cumo/cuda/nvrtc.c

@@ -0,0 +1,207 @@
+#include <ruby.h>
+#include <ruby/thread.h>
+#include <assert.h>
+#include <nvrtc.h>
+#include "cumo/cuda/nvrtc.h"
+
+VALUE cumo_cuda_eNVRTCError;
+VALUE cumo_cuda_mNVRTC;
+#define eNVRTCError cumo_cuda_eNVRTCError
+#define mNVRTC cumo_cuda_mNVRTC
+
+static void
+check_status(nvrtcResult status)
+{
+    if (status != 0) {
+        rb_raise(cumo_cuda_eNVRTCError, "%s (error=%d)", nvrtcGetErrorString(status), status);
+    }
+}
+
+static VALUE
+rb_nvrtcVersion(VALUE self)
+{
+    int _major, _minor;
+    nvrtcResult status;
+    VALUE major, minor;
+
+    status = nvrtcVersion(&_major, &_minor);
+
+    check_status(status);
+    major = INT2NUM(_major);
+    minor = INT2NUM(_minor);
+    return rb_ary_new3(2, major, minor);
+}
+
+struct nvrtcCreateProgramParam {
+    nvrtcProgram *prog;
+    const char* src;
+    const char *name;
+    int numHeaders;
+    const char** headers;
+    const char** includeNames;
+};
+
+static void*
+nvrtcCreateProgram_without_gvl_cb(void *param)
+{
+    struct nvrtcCreateProgramParam *p = param;
+    nvrtcResult status;
+    status = nvrtcCreateProgram(p->prog, p->src, p->name, p->numHeaders, p->headers, p->includeNames);
+    return (void *)status;
+}
+
+static VALUE
+rb_nvrtcCreateProgram(
+        VALUE self,
+        VALUE src,
+        VALUE name,
+        VALUE headers,
+        VALUE includeNames)
+{
+    nvrtcResult status;
+    nvrtcProgram _prog;
+    const char* _src = StringValueCStr(src);
+    const char* _name = StringValueCStr(name);
+    int _numHeaders = RARRAY_LEN(headers);
+    const char** _headers = (const char **)malloc(_numHeaders * sizeof(char *));
+    const char** _includeNames = (const char **)malloc(_numHeaders * sizeof(char *));
+    int i;
+    for (i = 0; i < _numHeaders; i++) {
+        VALUE header = RARRAY_PTR(headers)[i];
+        _headers[i] = StringValueCStr(header);
+    }
+    for (i = 0; i < _numHeaders; i++) {
+        VALUE include_name = RARRAY_PTR(includeNames)[i];
+        _includeNames[i] = StringValueCStr(include_name);
+    }
+
+    {
+        struct nvrtcCreateProgramParam param = {&_prog, _src, _name, _numHeaders, _headers, _includeNames};
+        status = (nvrtcResult)rb_thread_call_without_gvl(nvrtcCreateProgram_without_gvl_cb, &param, NULL, NULL);
+    }
+
+    free(_headers);
+    free(_includeNames);
+    check_status(status);
+    return SIZET2NUM((size_t)_prog);
+}
+
+struct nvrtcDestroyProgramParam {
+    nvrtcProgram *prog;
+};
+
+static void*
+nvrtcDestroyProgram_without_gvl_cb(void *param)
+{
+    struct nvrtcDestroyProgramParam *p = param;
+    nvrtcResult status;
+    status = nvrtcDestroyProgram(p->prog);
+    return (void *)status;
+}
+
+static VALUE
+rb_nvrtcDestroyProgram(VALUE self, VALUE prog)
+{
+    nvrtcResult status;
+    nvrtcProgram _prog = (nvrtcProgram)NUM2SIZET(prog);
+
+    struct nvrtcDestroyProgramParam param = {&_prog};
+    status = (nvrtcResult)rb_thread_call_without_gvl(nvrtcDestroyProgram_without_gvl_cb, &param, NULL, NULL);
+
+    check_status(status);
+    return Qnil;
+}
+
+struct nvrtcCompileProgramParam {
+    nvrtcProgram prog;
+    int numOptions;
+    const char** options;
+};
+
+static void*
+nvrtcCompileProgram_without_gvl_cb(void *param)
+{
+    struct nvrtcCompileProgramParam *p = param;
+    nvrtcResult status;
+    status = nvrtcCompileProgram(p->prog, p->numOptions, p->options);
+    return (void *)status;
+}
+
+static VALUE
+rb_nvrtcCompileProgram(VALUE self, VALUE prog, VALUE options)
+{
+    nvrtcResult status;
+    nvrtcProgram _prog = (nvrtcProgram)NUM2SIZET(prog);
+    int _numOptions = RARRAY_LEN(options);
+    const char** _options = (const char **)malloc(_numOptions * sizeof(char *));
+    int i;
+    for (i = 0; i < _numOptions; i++) {
+        VALUE option = RARRAY_PTR(options)[i];
+        _options[i] = StringValueCStr(option);
+    }
+
+    {
+        struct nvrtcCompileProgramParam param = {_prog, _numOptions, _options};
+        status = (nvrtcResult)rb_thread_call_without_gvl(nvrtcCompileProgram_without_gvl_cb, &param, NULL, NULL);
+    }
+
+    free(_options);
+    check_status(status);
+    return Qnil;
+}
+
+static VALUE
+rb_nvrtcGetPTX(VALUE self, VALUE prog)
+{
+    nvrtcResult status;
+    nvrtcProgram _prog = (nvrtcProgram)NUM2SIZET(prog);
+    size_t _ptxSizeRet;
+    char *_ptx;
+    VALUE ptx;
+
+    status = nvrtcGetPTXSize(_prog, &_ptxSizeRet);
+    check_status(status);
+
+    ptx = rb_str_new(NULL, _ptxSizeRet);
+    _ptx = RSTRING_PTR(ptx);
+    status = nvrtcGetPTX(_prog, _ptx);
+    check_status(status);
+
+    return ptx;
+}
+
+static VALUE
+rb_nvrtcGetProgramLog(VALUE self, VALUE prog)
+{
+    nvrtcResult status;
+    nvrtcProgram _prog = (nvrtcProgram)NUM2SIZET(prog);
+    size_t _logSizeRet;
+    char *_log;
+    VALUE log;
+
+    status = nvrtcGetProgramLogSize(_prog, &_logSizeRet);
+    check_status(status);
+
+    log = rb_str_new(NULL, _logSizeRet);
+    _log = RSTRING_PTR(log);
+    status = nvrtcGetProgramLog(_prog, _log);
+    check_status(status);
+
+    return log;
+}
+
+void
+Init_cumo_cuda_nvrtc()
+{
+    VALUE mCumo = rb_define_module("Cumo");
+    VALUE mCUDA = rb_define_module_under(mCumo, "CUDA");
+    mNVRTC = rb_define_module_under(mCUDA, "NVRTC");
+    eNVRTCError = rb_define_class_under(mCUDA, "NVRTCError", rb_eStandardError);
+
+    rb_define_singleton_method(mNVRTC, "nvrtcVersion", rb_nvrtcVersion, 0);
+    rb_define_singleton_method(mNVRTC, "nvrtcCreateProgram", rb_nvrtcCreateProgram, 4);
+    rb_define_singleton_method(mNVRTC, "nvrtcDestroyProgram", rb_nvrtcDestroyProgram, 1);
+    rb_define_singleton_method(mNVRTC, "nvrtcCompileProgram", rb_nvrtcCompileProgram, 2);
+    rb_define_singleton_method(mNVRTC, "nvrtcGetPTX", rb_nvrtcGetPTX, 1);
+    rb_define_singleton_method(mNVRTC, "nvrtcGetProgramLog", rb_nvrtcGetProgramLog, 1);
+}

data/ext/cumo/cuda/runtime.c

@@ -0,0 +1,167 @@
+#include <ruby.h>
+#include <assert.h>
+#include <cuda_runtime.h>
+#include "cumo/cuda/runtime.h"
+
+VALUE cumo_cuda_eRuntimeError;
+VALUE cumo_cuda_mRuntime;
+#define eRuntimeError cumo_cuda_eRuntimeError
+#define mRuntime cumo_cuda_mRuntime
+
+#define check_status(status) (cumo_cuda_runtime_check_status((status)))
+
+///////////////////////////////////////////
+// Version Management
+///////////////////////////////////////////
+
+/*
+  Returns the CUDA driver version.
+
+  @return [Integer] Returns the CUDA driver version.
+  @see http://docs.nvidia.com/cuda/cuda-runtime-api/group__CUDART____VERSION.html#group__CUDART____VERSION_1g8a06ee14a0551606b7c780084d5564ab
+ */
+static VALUE
+rb_cudaDriverGetVersion(VALUE self)
+{
+    int _version;
+    cudaError_t status;
+
+    status = cudaDriverGetVersion(&_version);
+
+    check_status(status);
+    return INT2NUM(_version);
+}
+
+/*
+  Returns the CUDA Runtime version.
+
+  @return [Integer] Returns the CUDA Runtime version.
+  @see http://docs.nvidia.com/cuda/cuda-runtime-api/group__CUDART____VERSION.html#group__CUDART____VERSION_1g0e3952c7802fd730432180f1f4a6cdc6
+ */
+static VALUE
+rb_cudaRuntimeGetVersion(VALUE self)
+{
+    int _version;
+    cudaError_t status;
+
+    status = cudaRuntimeGetVersion(&_version);
+
+    check_status(status);
+    return INT2NUM(_version);
+}
+
+/////////////////////////////////////////
+// Device and context operations
+/////////////////////////////////////////
+
+/*
+  Returns which device is currently being used.
+
+  @return [Integer] Returns the device on which the active host thread executes the device code.
+  @raise [Cumo::CUDA::RuntimeError]
+  @see http://docs.nvidia.com/cuda/cuda-runtime-api/group__CUDART__DEVICE.html#group__CUDART__DEVICE_1g80861db2ce7c29b6e8055af8ae01bc78
+ */
+static VALUE
+rb_cudaGetDevice(VALUE self)
+{
+    int _device;
+    cudaError_t status;
+
+    status = cudaGetDevice(&_device);
+
+    check_status(status);
+    return INT2NUM(_device);
+}
+
+/*
+  Returns information about the device.
+
+  @param [Integer] attrib Device attribute to query
+  @param [Integer] device Device number to query
+  @return [Integer] Returned device attribute value
+  @raise [Cumo::CUDA::RuntimeError]
+  @see http://docs.nvidia.com/cuda/cuda-runtime-api/group__CUDART__DEVICE.html#group__CUDART__DEVICE_1gb22e8256592b836df9a9cc36c9db7151
+ */
+static VALUE
+rb_cudaDeviceGetAttributes(VALUE self, VALUE attrib, VALUE device)
+{
+    int _attrib = NUM2INT(attrib);
+    int _device = NUM2INT(device);
+    int _ret;
+    cudaError_t status;
+
+    status = cudaDeviceGetAttribute(&_ret, _attrib, _device);
+
+    check_status(status);
+    return INT2NUM(_ret);
+}
+
+/*
+  Returns the number of compute-capable devices.
+
+  @return [Integer] Returns the number of devices with compute capability greater or equal to 2.0
+  @raise [Cumo::CUDA::RuntimeError]
+  @see http://docs.nvidia.com/cuda/cuda-runtime-api/group__CUDART__DEVICE.html#group__CUDART__DEVICE_1g18808e54893cfcaafefeab31a73cc55f
+ */
+static VALUE
+rb_cudaGetDeviceCount(VALUE self)
+{
+    int _count;
+    cudaError_t status;
+
+    status = cudaGetDeviceCount(&_count);
+
+    check_status(status);
+    return INT2NUM(_count);
+}
+
+/*
+  Set device to be used for GPU executions.
+
+  @param [Integer] device Device on which the active host thread should execute the device code.
+  @raise [Cumo::CUDA::RuntimeError]
+  @see http://docs.nvidia.com/cuda/cuda-runtime-api/group__CUDART__DEVICE.html#group__CUDART__DEVICE_1g159587909ffa0791bbe4b40187a4c6bb
+ */
+static VALUE
+rb_cudaSetDevice(VALUE self, VALUE device)
+{
+    int _device = NUM2INT(device);
+    cudaError_t status;
+
+    status = cudaSetDevice(_device);
+
+    check_status(status);
+    return Qnil;
+}
+
+/*
+  Wait for compute device to finish.
+
+  @raise [Cumo::CUDA::RuntimeError]
+  @see http://docs.nvidia.com/cuda/cuda-runtime-api/group__CUDART__DEVICE.html#group__CUDART__DEVICE_1g10e20b05a95f638a4071a655503df25d
+ */
+static VALUE
+rb_cudaDeviceSynchronize(VALUE self)
+{
+    cudaError_t status;
+    status = cudaDeviceSynchronize();
+    check_status(status);
+    return Qnil;
+}
+
+void
+Init_cumo_cuda_runtime()
+{
+    VALUE mCumo = rb_define_module("Cumo");
+    VALUE mCUDA = rb_define_module_under(mCumo, "CUDA");
+    mRuntime = rb_define_module_under(mCUDA, "Runtime");
+    eRuntimeError = rb_define_class_under(mCUDA, "RuntimeError", rb_eStandardError);
+
+    rb_define_singleton_method(mRuntime, "cudaDriverGetVersion", rb_cudaDriverGetVersion, 0);
+    rb_define_singleton_method(mRuntime, "cudaRuntimeGetVersion", rb_cudaRuntimeGetVersion, 0);
+    rb_define_singleton_method(mRuntime, "cudaGetDevice", rb_cudaGetDevice, 0);
+    rb_define_singleton_method(mRuntime, "cudaDeviceGetAttributes", rb_cudaDeviceGetAttributes, 2);
+    rb_define_singleton_method(mRuntime, "cudaGetDeviceCount", rb_cudaGetDeviceCount, 0);
+    rb_define_singleton_method(mRuntime, "cudaSetDevice", rb_cudaSetDevice, 1);
+    rb_define_singleton_method(mRuntime, "cudaDeviceSynchronize", rb_cudaDeviceSynchronize, 0);
+}

data/ext/cumo/cumo.c

@@ -0,0 +1,148 @@
+#define CUMO_C
+#include <ruby.h>
+#include <assert.h>
+#include <stdlib.h>
+#include "cumo.h"
+#include "cumo/narray.h"
+
+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_bit();
+void Init_cumo_int8();
+void Init_cumo_int16();
+void Init_cumo_int32();
+void Init_cumo_int64();
+void Init_cumo_uint8();
+void Init_cumo_uint16();
+void Init_cumo_uint32();
+void Init_cumo_uint64();
+void Init_cumo_sfloat();
+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_cuda_driver();
+void Init_cumo_cuda_memory_pool();
+void Init_cumo_cuda_runtime();
+void Init_cumo_cuda_nvrtc();
+
+void
+cumo_debug_breakpoint(void)
+{
+    /* */
+}
+
+static bool cumo_compatible_mode_enabled;
+
+bool cumo_compatible_mode_enabled_p()
+{
+    return cumo_compatible_mode_enabled;
+}
+
+/*
+  Enable Numo NArray compatible mode.
+
+  Cumo returns 0-dimensional NArray instead of ruby numeric object
+  for some methods such as `extract`, and `[]` not to synchronize
+  between CPU and GPU for performance as default.
+
+  Enabling the compatible mode makes Cumo behave as Numo. But, please
+  note that it makes Cumo slow.
+
+  @return [Boolean] Returns previous state (true if enabled)
+ */
+static VALUE
+rb_enable_compatible_mode(VALUE self)
+{
+    VALUE ret = (cumo_compatible_mode_enabled ? Qtrue : Qfalse);
+    cumo_compatible_mode_enabled = true;
+    return ret;
+}
+
+/*
+  Disable Numo NArray compatible mode.
+
+  @return [Boolean] Returns previous state (true if enabled)
+ */
+static VALUE
+rb_disable_compatible_mode(VALUE self)
+{
+    VALUE ret = (cumo_compatible_mode_enabled ? Qtrue : Qfalse);
+    cumo_compatible_mode_enabled = false;
+    return ret;
+}
+
+/*
+  Returns whether Numo NArray compatible mode is enabled or not.
+
+  @return [Boolean] Returns the state (true if enabled)
+ */
+static VALUE
+rb_compatible_mode_enabled_p(VALUE self)
+{
+    return (cumo_compatible_mode_enabled ? Qtrue : Qfalse);
+}
+
+/* initialization of Cumo Module */
+void
+Init_cumo()
+{
+    const char* env;
+    VALUE mCumo;
+
+    mCumo = rb_define_module("Cumo");
+
+    rb_define_const(mCumo, "VERSION", rb_str_new2(CUMO_VERSION));
+
+    rb_define_singleton_method(mCumo, "enable_compatible_mode", RUBY_METHOD_FUNC(rb_enable_compatible_mode), 0);
+    rb_define_singleton_method(mCumo, "disable_compatible_mode", RUBY_METHOD_FUNC(rb_disable_compatible_mode), 0);
+    rb_define_singleton_method(mCumo, "compatible_mode_enabled?", RUBY_METHOD_FUNC(rb_compatible_mode_enabled_p), 0);
+
+    // default is false
+    env = getenv("CUMO_COMPATIBLE_MODE");
+    cumo_compatible_mode_enabled = (env != NULL && strcmp(env, "OFF") != 0 && strcmp(env, "0") != 0 && strcmp(env, "NO") != 0);
+
+    Init_cumo_narray();
+
+    Init_cumo_nary_step();
+    Init_cumo_nary_index();
+
+    Init_cumo_nary_data();
+    Init_cumo_nary_ndloop();
+
+    Init_cumo_dcomplex();
+    Init_cumo_dfloat();
+    Init_cumo_scomplex();
+    Init_cumo_sfloat();
+
+    Init_cumo_int64();
+    Init_cumo_uint64();
+    Init_cumo_int32();
+    Init_cumo_uint32();
+    Init_cumo_int16();
+    Init_cumo_uint16();
+    Init_cumo_int8();
+    Init_cumo_uint8();
+
+    Init_cumo_bit();
+    Init_cumo_robject();
+
+    Init_cumo_nary_math();
+
+    Init_cumo_nary_rand();
+    Init_cumo_nary_array();
+    Init_cumo_nary_struct();
+
+    Init_cumo_cuda_driver();
+    Init_cumo_cuda_memory_pool();
+    Init_cumo_cuda_runtime();
+    Init_cumo_cuda_nvrtc();
+}