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 



100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
# 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);
    // The image may be a cubin, so it is taken by length and allowed to hold
    // NUL bytes; the name is a plain C string cuLinkAddData reports errors with.
    void* _data = (void *)StringValuePtr(data);
    size_t _size = RSTRING_LEN(data);
    const char* _name = StringValueCStr(name);
    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);

    RB_GC_GUARD(data);
    RB_GC_GUARD(name);
    check_status(status);
    return Qnil;
}

.cuLinkAddFile(state, type, path) ⇒ Object 



141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
 
# File 'ext/cumo/cuda/driver.c', line 141

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 = StringValueCStr(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);

    RB_GC_GUARD(path);
    check_status(status);
    return Qnil;
}

.cuLinkComplete(state) ⇒ Object 



173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
 
# File 'ext/cumo/cuda/driver.c', line 173

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 



206
207
208
209
210
211
212
213
214
215
216
217
218
 
# File 'ext/cumo/cuda/driver.c', line 206

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 



233
234
235
236
237
238
239
240
241
242
243
244
245
 
# File 'ext/cumo/cuda/driver.c', line 233

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 



262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
 
# File 'ext/cumo/cuda/driver.c', line 262

static VALUE
rb_cuModuleGetFunction(VALUE self, VALUE hmod, VALUE name)
{
    CUfunction _hfunc;
    CUmodule _hmod = (CUmodule)NUM2SIZET(hmod);
    const char* _name = StringValueCStr(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);

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

.cuModuleGetGlobal(hmod, name) ⇒ Object 



295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
 
# File 'ext/cumo/cuda/driver.c', line 295

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

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

    RB_GC_GUARD(name);
    check_status(status);

    // _dptr addresses device memory, which the host cannot read directly.
    ret = rb_str_new(NULL, (long)_bytes);
    check_status(cuMemcpyDtoH(RSTRING_PTR(ret), _dptr, _bytes));
    return ret;
}

.cuModuleLoad(fname) ⇒ Object 



332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
 
# File 'ext/cumo/cuda/driver.c', line 332

static VALUE
rb_cuModuleLoad(VALUE self, VALUE fname)
{
    CUmodule _module;
    const char* _fname = StringValueCStr(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);

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

.cuModuleLoadData(image) ⇒ Object 



362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
 
# File 'ext/cumo/cuda/driver.c', line 362

static VALUE
rb_cuModuleLoadData(VALUE self, VALUE image)
{
    CUmodule _module;
    // A cubin is binary, so the image is not required to be NUL-free.
    const void* _image = (void*)StringValuePtr(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);

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

.cuModuleUnload(hmod) ⇒ Object 



392
393
394
395
396
397
398
399
400
401
402
403
404
 
# File 'ext/cumo/cuda/driver.c', line 392

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