Module: Cumo::CUDA::Driver

Defined in:
ext/cumo/cuda/driver.c

Constant Summary collapse

CU_JIT_INPUT_CUBIN = 
INT2NUM(CU_JIT_INPUT_CUBIN)
CU_JIT_INPUT_FATBINARY = 
INT2NUM(CU_JIT_INPUT_FATBINARY)
CU_JIT_INPUT_LIBRARY = 
INT2NUM(CU_JIT_INPUT_LIBRARY)
CU_JIT_INPUT_OBJECT = 
INT2NUM(CU_JIT_INPUT_OBJECT)
CU_JIT_INPUT_PTX = 
INT2NUM(CU_JIT_INPUT_PTX)

Class Method Summary collapse

Class Method Details

.cuCtxCreate(flags, dev) ⇒ Object

////////////////////////////////////////////



28
29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'ext/cumo/cuda/driver.c', line 28

static VALUE
rb_cuCtxCreate(VALUE self, VALUE flags, VALUE dev)
{
    unsigned int _flags = NUM2INT(flags);
    CUdevice _dev = (CUdevice)NUM2INT(dev);
    CUcontext _pctx;
    CUresult status;

    status = cuCtxCreate(&_pctx, _flags, _dev);

    check_status(status);
    return SIZET2NUM((size_t)_pctx);
}

.cuCtxGetCurrent ⇒ Object 



42
43
44
45
46
47
48
49
50
51
52
 
# File 'ext/cumo/cuda/driver.c', line 42

static VALUE
rb_cuCtxGetCurrent(VALUE self)
{
    CUcontext ctx;
    CUresult status;

    status = cuCtxGetCurrent(&ctx);
    check_status(status);

    return SIZET2NUM((size_t)ctx);
}

.cuDeviceGet(ordinal) ⇒ Object

////////////////////////////////////////////



58
59
60
61
62
63
64
65
66
67
68
69
 
# File 'ext/cumo/cuda/driver.c', line 58

static VALUE
rb_cuDeviceGet(VALUE self, VALUE ordinal)
{
    int _ordinal = NUM2INT(ordinal);
    CUdevice _device;
    CUresult status;

    status = cuDeviceGet(&_device, _ordinal);

    check_status(status);
    return INT2NUM(_device);
}

.cuLinkAddData(state, type, data, name) ⇒ Object

TODO(sonots): Support options.



96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'ext/cumo/cuda/driver.c', line 96

static VALUE
rb_cuLinkAddData(VALUE self, VALUE state, VALUE type, VALUE data, VALUE name)
{
    CUlinkState _state = (CUlinkState)NUM2SIZET(state);
    CUjitInputType _type = (CUjitInputType)NUM2INT(type);
    void* _data = (void *)RSTRING_PTR(data);
    size_t _size = RSTRING_LEN(data);
    const char* _name = RSTRING_PTR(data);
    CUresult status;

    struct cuLinkAddDataParam param = {_state, _type, _data, _size, _name, 0, (CUjit_option*)0, (void**)0};
    status = (CUresult)rb_thread_call_without_gvl(cuLinkAddData_without_gvl_cb, &param, NULL, NULL);
    //status = cuLinkAddData(_state, _type, _data, _size, _name, 0, (CUjit_option*)0, (void**)0);

    check_status(status);
    return Qnil;
}

.cuLinkAddFile(state, type, path) ⇒ Object

TODO(sonots): Support options.



133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
 
# File 'ext/cumo/cuda/driver.c', line 133

static VALUE
rb_cuLinkAddFile(VALUE self, VALUE state, VALUE type, VALUE path)
{
    CUlinkState _state = (CUlinkState)NUM2SIZET(state);
    CUjitInputType _type = (CUjitInputType)NUM2INT(type);
    const char* _path = RSTRING_PTR(path);
    CUresult status;

    struct cuLinkAddFileParam param = {_state, _type, _path, 0, (CUjit_option*)0, (void **)0};
    status = (CUresult)rb_thread_call_without_gvl(cuLinkAddFile_without_gvl_cb, &param, NULL, NULL);
    //status = cuLinkAddFile(_state, _type, _path, 0, (CUjit_option*)0, (void **)0);

    check_status(status);
    return Qnil;
}

.cuLinkComplete(state) ⇒ Object 



164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
 
# File 'ext/cumo/cuda/driver.c', line 164

static VALUE
rb_cuLinkComplete(VALUE self, VALUE state)
{
    CUlinkState _state = (CUlinkState)NUM2SIZET(state);
    void* _cubinOut;
    size_t _sizeOut;
    CUresult status;

    struct cuLinkCompleteParam param = {_state, &_cubinOut, &_sizeOut};
    status = (CUresult)rb_thread_call_without_gvl(cuLinkComplete_without_gvl_cb, &param, NULL, NULL);
    //status = cuLinkComplete(_state, &_cubinOut, &_sizeOut);

    check_status(status);
    return rb_str_new((char *)_cubinOut, _sizeOut);
}

.cuLinkCreate ⇒ Object

TODO(sonots): Support options.



197
198
199
200
201
202
203
204
205
206
207
208
209
 
# File 'ext/cumo/cuda/driver.c', line 197

static VALUE
rb_cuLinkCreate(VALUE self)
{
    CUlinkState state;
    CUresult status;

    struct cuLinkCreateParam param = {0, (CUjit_option*)0, (void**)0, &state};
    status = (CUresult)rb_thread_call_without_gvl(cuLinkCreate_without_gvl_cb, &param, NULL, NULL);
    //status = cuLinkCreate(0, (CUjit_option*)0, (void**)0, &state);

    check_status(status);
    return SIZET2NUM((size_t)state);
}

.cuLinkDestroy(state) ⇒ Object 



224
225
226
227
228
229
230
231
232
233
234
235
236
 
# File 'ext/cumo/cuda/driver.c', line 224

static VALUE
rb_cuLinkDestroy(VALUE self, VALUE state)
{
    CUlinkState _state = (CUlinkState)NUM2SIZET(state);
    CUresult status;

    struct cuLinkDestroyParam param = {_state};
    status = (CUresult)rb_thread_call_without_gvl(cuLinkDestroy_without_gvl_cb, &param, NULL, NULL);
    //status = cuLinkDestroy(_state);

    check_status(status);
    return Qnil;
}

.cuModuleGetFunction(hmod, name) ⇒ Object 



253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
 
# File 'ext/cumo/cuda/driver.c', line 253

static VALUE
rb_cuModuleGetFunction(VALUE self, VALUE hmod, VALUE name)
{
    CUfunction _hfunc;
    CUmodule _hmod = (CUmodule)NUM2SIZET(hmod);
    const char* _name = RSTRING_PTR(name);
    CUresult status;

    struct cuModuleGetFunctionParam param = {&_hfunc, _hmod, _name};
    status = (CUresult)rb_thread_call_without_gvl(cuModuleGetFunction_without_gvl_cb, &param, NULL, NULL);
    //status = cuModuleGetFunction(&_hfunc, _hmod, _name);

    check_status(status);
    return SIZET2NUM((size_t)_hfunc);
}

.cuModuleGetGlobal(hmod, name) ⇒ Object 



285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
 
# File 'ext/cumo/cuda/driver.c', line 285

static VALUE
rb_cuModuleGetGlobal(VALUE self, VALUE hmod, VALUE name)
{
    CUdeviceptr _dptr;
    size_t _bytes;
    CUmodule _hmod = (CUmodule)NUM2SIZET(hmod);
    const char* _name = RSTRING_PTR(name);
    CUresult status;

    struct cuModuleGetGlobalParam param = {&_dptr, &_bytes, _hmod, _name};
    status = (CUresult)rb_thread_call_without_gvl(cuModuleGetGlobal_without_gvl_cb, &param, NULL, NULL);
    //status = cuModuleGetGlobal(&_dptr, &_bytes, _hmod, _name);

    check_status(status);
    return rb_str_new((char *)_dptr, _bytes);
}

.cuModuleLoad(fname) ⇒ Object 



316
317
318
319
320
321
322
323
324
325
326
327
328
329
 
# File 'ext/cumo/cuda/driver.c', line 316

static VALUE
rb_cuModuleLoad(VALUE self, VALUE fname)
{
    CUmodule _module;
    const char* _fname = RSTRING_PTR(fname);
    CUresult status;

    struct cuModuleLoadParam param = {&_module, _fname};
    status = (CUresult)rb_thread_call_without_gvl(cuModuleLoad_without_gvl_cb, &param, NULL, NULL);
    //status = cuModuleLoad(&_module, _fname);

    check_status(status);
    return SIZET2NUM((size_t)_module);
}

.cuModuleLoadData(image) ⇒ Object 



345
346
347
348
349
350
351
352
353
354
355
356
357
358
 
# File 'ext/cumo/cuda/driver.c', line 345

static VALUE
rb_cuModuleLoadData(VALUE self, VALUE image)
{
    CUmodule _module;
    const void* _image = (void*)RSTRING_PTR(image);
    CUresult status;

    struct cuModuleLoadDataParam param = {&_module, _image};
    status = (CUresult)rb_thread_call_without_gvl(cuModuleLoadData_without_gvl_cb, &param, NULL, NULL);
    //status = cuModuleLoadData(&_module, _image);

    check_status(status);
    return SIZET2NUM((size_t)_module);
}

.cuModuleUnload(hmod) ⇒ Object 



373
374
375
376
377
378
379
380
381
382
383
384
385
 
# File 'ext/cumo/cuda/driver.c', line 373

static VALUE
rb_cuModuleUnload(VALUE self, VALUE hmod)
{
    CUmodule _hmod = (CUmodule)NUM2SIZET(hmod);
    CUresult status;

    struct cuModuleUnloadParam param = {_hmod};
    status = (CUresult)rb_thread_call_without_gvl(cuModuleUnload_without_gvl_cb, &param, NULL, NULL);
    //status = cuModuleUnload(_hmod);

    check_status(status);
    return Qnil;
}