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
41
42
43
44
 
# 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;

#if defined(CUDA_VERSION) && CUDA_VERSION >= 13000
    status = cuCtxCreate(&_pctx, NULL, _flags, _dev);
#else
    status = cuCtxCreate(&_pctx, _flags, _dev);
#endif

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

.cuCtxGetCurrent ⇒ Object 



46
47
48
49
50
51
52
53
54
55
56
 
# File 'ext/cumo/cuda/driver.c', line 46

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

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

    return SIZET2NUM((size_t)ctx);
}

.cuDeviceGet(ordinal) ⇒ Object

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



62
63
64
65
66
67
68
69
70
71
72
73
 
# File 'ext/cumo/cuda/driver.c', line 62

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.



100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
 
# File 'ext/cumo/cuda/driver.c', line 100

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.



137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
 
# File 'ext/cumo/cuda/driver.c', line 137

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 



168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
 
# File 'ext/cumo/cuda/driver.c', line 168

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.



201
202
203
204
205
206
207
208
209
210
211
212
213
 
# File 'ext/cumo/cuda/driver.c', line 201

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 



228
229
230
231
232
233
234
235
236
237
238
239
240
 
# File 'ext/cumo/cuda/driver.c', line 228

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 



257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
 
# File 'ext/cumo/cuda/driver.c', line 257

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 



289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
 
# File 'ext/cumo/cuda/driver.c', line 289

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 



320
321
322
323
324
325
326
327
328
329
330
331
332
333
 
# File 'ext/cumo/cuda/driver.c', line 320

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 



349
350
351
352
353
354
355
356
357
358
359
360
361
362
 
# File 'ext/cumo/cuda/driver.c', line 349

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 



377
378
379
380
381
382
383
384
385
386
387
388
389
 
# File 'ext/cumo/cuda/driver.c', line 377

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;
}