Coverage for cuda / bindings / _lib / utils.pxi: 57%
375 statements
« prev ^ index » next coverage.py v7.13.0, created at 2025-12-10 01:19 +0000
1# SPDX-FileCopyrightText: Copyright (c) 2021-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
2# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
4from cpython.buffer cimport PyObject_CheckBuffer, PyObject_GetBuffer, PyBuffer_Release, PyBUF_SIMPLE, PyBUF_ANY_CONTIGUOUS
5from libc.stdlib cimport calloc, free
6from libc.stdint cimport int32_t, uint32_t, int64_t, uint64_t
7from libc.stddef cimport wchar_t
8from libc.string cimport memcpy
9from enum import Enum as _Enum
10import ctypes as _ctypes
11cimport cuda.bindings.cydriver as cydriver
12cimport cuda.bindings._lib.param_packer as param_packer
14cdef void* _callocWrapper(length, size):
15 cdef void* out = calloc(length, size)
16 if out is NULL:
17 raise MemoryError('Failed to allocated length x size memory: {}x{}'.format(length, size))
18 return out
20cdef class _HelperKernelParams:
21 supported_types = { # excluding void_p and None, which are handled specially
22 _ctypes.c_bool,
23 _ctypes.c_char,
24 _ctypes.c_wchar,
25 _ctypes.c_byte,
26 _ctypes.c_ubyte,
27 _ctypes.c_short,
28 _ctypes.c_ushort,
29 _ctypes.c_int,
30 _ctypes.c_uint,
31 _ctypes.c_long,
32 _ctypes.c_ulong,
33 _ctypes.c_longlong,
34 _ctypes.c_ulonglong,
35 _ctypes.c_size_t,
36 _ctypes.c_float,
37 _ctypes.c_double
38 }
40 max_param_size = max(_ctypes.sizeof(max(_HelperKernelParams.supported_types, key=lambda t:_ctypes.sizeof(t))), sizeof(void_ptr))
42 def __cinit__(self, kernelParams):
43 self._pyobj_acquired = False
44 self._malloc_list_created = False
45 if kernelParams is None:
46 self._ckernelParams = NULL
47 elif isinstance(kernelParams, (int)):
48 # Easy run, user gave us an already configured void** address
49 self._ckernelParams = <void**><void_ptr>kernelParams
50 elif PyObject_CheckBuffer(kernelParams):
51 # Easy run, get address from Python Buffer Protocol
52 err_buffer = PyObject_GetBuffer(kernelParams, &self._pybuffer, PyBUF_SIMPLE | PyBUF_ANY_CONTIGUOUS)
53 if err_buffer == -1:
54 raise RuntimeError("Argument 'kernelParams' failed to retrieve buffer through Buffer Protocol")
55 self._pyobj_acquired = True
56 self._ckernelParams = <void**><void_ptr>self._pybuffer.buf
57 elif isinstance(kernelParams, (tuple)) and len(kernelParams) == 2 and isinstance(kernelParams[0], (tuple)) and isinstance(kernelParams[1], (tuple)):
58 # Hard run, construct and fill out contigues memory using provided kernel values and types based
59 if len(kernelParams[0]) != len(kernelParams[1]):
60 raise TypeError("Argument 'kernelParams' has tuples with different length")
61 if len(kernelParams[0]) != 0:
62 self._length = len(kernelParams[0])
63 self._ckernelParams = <void**>_callocWrapper(len(kernelParams[0]), sizeof(void*))
64 self._ckernelParamsData = <char*>_callocWrapper(len(kernelParams[0]), _HelperKernelParams.max_param_size)
65 self._malloc_list_created = True
67 idx = 0
68 data_idx = 0
69 for value, ctype in zip(kernelParams[0], kernelParams[1]):
70 if ctype is None:
71 # special cases for None
72 if callable(getattr(value, 'getPtr', None)):
73 self._ckernelParams[idx] = <void*><void_ptr>value.getPtr()
74 elif isinstance(value, (_ctypes.Structure)):
75 self._ckernelParams[idx] = <void*><void_ptr>_ctypes.addressof(value)
76 elif isinstance(value, (_Enum)):
77 self._ckernelParams[idx] = &(self._ckernelParamsData[data_idx])
78 (<int*>self._ckernelParams[idx])[0] = value.value
79 data_idx += sizeof(int)
80 else:
81 raise TypeError("Provided argument is of type {} but expected Type {}, {} or CUDA Binding structure with getPtr() attribute".format(type(value), type(_ctypes.Structure), type(_ctypes.c_void_p)))
82 elif ctype in _HelperKernelParams.supported_types:
83 self._ckernelParams[idx] = &(self._ckernelParamsData[data_idx])
85 # handle case where a float is passed as a double
86 if ctype == _ctypes.c_double and isinstance(value, _ctypes.c_float):
87 value = ctype(value.value)
88 if not isinstance(value, ctype): # make it a ctype
89 size = param_packer.feed(self._ckernelParams[idx], value, ctype)
90 if size == 0: # feed failed
91 value = ctype(value)
92 size = _ctypes.sizeof(ctype)
93 addr = <void*>(<void_ptr>_ctypes.addressof(value))
94 memcpy(self._ckernelParams[idx], addr, size)
95 else:
96 size = _ctypes.sizeof(ctype)
97 addr = <void*>(<void_ptr>_ctypes.addressof(value))
98 memcpy(self._ckernelParams[idx], addr, size)
99 data_idx += size
100 elif ctype == _ctypes.c_void_p:
101 # special cases for void_p
102 if isinstance(value, (int, _ctypes.c_void_p)):
103 self._ckernelParams[idx] = &(self._ckernelParamsData[data_idx])
104 (<void_ptr*>self._ckernelParams[idx])[0] = value.value if isinstance(value, (_ctypes.c_void_p)) else value
105 data_idx += sizeof(void_ptr)
106 elif callable(getattr(value, 'getPtr', None)):
107 self._ckernelParams[idx] = &(self._ckernelParamsData[data_idx])
108 (<void_ptr*>self._ckernelParams[idx])[0] = value.getPtr()
109 data_idx += sizeof(void_ptr)
110 else:
111 raise TypeError("Provided argument is of type {} but expected Type {}, {} or CUDA Binding structure with getPtr() attribute".format(type(value), type(int), type(_ctypes.c_void_p)))
112 else:
113 raise TypeError("Unsupported type: " + str(type(ctype)))
114 idx += 1
115 else:
116 raise TypeError("Argument 'kernelParams' is not a valid type: tuple[tuple[Any, ...], tuple[Any, ...]] or PyObject implimenting Buffer Protocol or Int")
118 def __dealloc__(self):
119 if self._pyobj_acquired is True:
120 PyBuffer_Release(&self._pybuffer)
121 if self._malloc_list_created is True:
122 free(self._ckernelParams)
123 free(self._ckernelParamsData)
125 @property
126 def ckernelParams(self):
127 return <void_ptr>self._ckernelParams
129cdef class _HelperInputVoidPtr:
130 def __cinit__(self, ptr):
131 self._pyobj_acquired = False
132 if ptr is None:
133 self._cptr = NULL
134 elif isinstance(ptr, (int)):
135 # Easy run, user gave us an already configured void** address
136 self._cptr = <void*><void_ptr>ptr
137 elif isinstance(ptr, (_driver["CUdeviceptr"])):
138 self._cptr = <void*><void_ptr>int(ptr)
139 elif PyObject_CheckBuffer(ptr):
140 # Easy run, get address from Python Buffer Protocol
141 err_buffer = PyObject_GetBuffer(ptr, &self._pybuffer, PyBUF_SIMPLE | PyBUF_ANY_CONTIGUOUS)
142 if err_buffer == -1:
143 raise RuntimeError("Failed to retrieve buffer through Buffer Protocol")
144 self._pyobj_acquired = True
145 self._cptr = <void*><void_ptr>self._pybuffer.buf
146 else:
147 raise TypeError("Provided argument is of type {} but expected Type {}, {} or object with Buffer Protocol".format(type(ptr), type(None), type(int)))
149 def __dealloc__(self):
150 if self._pyobj_acquired is True:
151 PyBuffer_Release(&self._pybuffer)
153 @property
154 def cptr(self):
155 return <void_ptr>self._cptr
157cdef class _HelperCUmemPool_attribute:
158 def __cinit__(self, attr, init_value, is_getter=False):
159 self._is_getter = is_getter
160 self._attr = attr.value
161 if self._attr in (cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_FOLLOW_EVENT_DEPENDENCIES,
162 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_ALLOW_OPPORTUNISTIC,
163 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_ALLOW_INTERNAL_DEPENDENCIES,):
164 self._int_val = init_value
165 self._cptr = <void*>&self._int_val
166 elif self._attr in (cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RELEASE_THRESHOLD,
167 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RESERVED_MEM_CURRENT,
168 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RESERVED_MEM_HIGH,
169 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_USED_MEM_CURRENT,
170 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_USED_MEM_HIGH,):
171 if self._is_getter:
172 self._cuuint64_t_val = _driver["cuuint64_t"]()
173 self._cptr = <void*><void_ptr>self._cuuint64_t_val.getPtr()
174 else:
175 self._cptr = <void*><void_ptr>init_value.getPtr()
176 else:
177 raise TypeError('Unsupported attribute: {}'.format(attr.name))
179 def __dealloc__(self):
180 pass
182 @property
183 def cptr(self):
184 return <void_ptr>self._cptr
186 def pyObj(self):
187 assert(self._is_getter == True)
188 if self._attr in (cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_FOLLOW_EVENT_DEPENDENCIES,
189 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_ALLOW_OPPORTUNISTIC,
190 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_ALLOW_INTERNAL_DEPENDENCIES,):
191 return self._int_val
192 elif self._attr in (cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RELEASE_THRESHOLD,
193 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RESERVED_MEM_CURRENT,
194 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RESERVED_MEM_HIGH,
195 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_USED_MEM_CURRENT,
196 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_USED_MEM_HIGH,):
197 return self._cuuint64_t_val
198 else:
199 raise TypeError('Unsupported attribute value: {}'.format(self._attr))
201cdef class _HelperCUmem_range_attribute:
202 def __cinit__(self, attr, data_size):
203 self._data_size = data_size
204 self._attr = attr.value
205 if self._attr in (cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY,
206 cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION,
207 cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION,):
208 self._cptr = <void*>&self._int_val
209 elif self._attr in (cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY,):
210 self._cptr = _callocWrapper(1, self._data_size)
211 self._int_val_list = <int*>self._cptr
212 else:
213 raise TypeError('Unsupported attribute: {}'.format(attr.name))
215 def __dealloc__(self):
216 if self._attr in (cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY,):
217 free(self._cptr)
219 @property
220 def cptr(self):
221 return <void_ptr>self._cptr
223 def pyObj(self):
224 if self._attr in (cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY,
225 cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION,
226 cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION,):
227 return self._int_val
228 elif self._attr in (cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY,):
229 return [self._int_val_list[idx] for idx in range(int(self._data_size/4))]
230 else:
231 raise TypeError('Unsupported attribute value: {}'.format(self._attr))
233cdef class _HelperCUpointer_attribute:
234 def __cinit__(self, attr, init_value, is_getter=False):
235 self._is_getter = is_getter
236 self._attr = attr.value
237 if self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_CONTEXT,):
238 if self._is_getter:
239 self._ctx = _driver["CUcontext"]()
240 self._cptr = <void*><void_ptr>self._ctx.getPtr()
241 else:
242 self._cptr = <void*><void_ptr>init_value.getPtr()
243 elif self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MEMORY_TYPE,
244 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL,
245 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES,
246 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE,
247 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_ACCESS_FLAGS,):
248 self._uint = init_value
249 self._cptr = <void*>&self._uint
250 elif self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_DEVICE_POINTER,
251 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_RANGE_START_ADDR,):
252 if self._is_getter:
253 self._devptr = _driver["CUdeviceptr"]()
254 self._cptr = <void*><void_ptr>self._devptr.getPtr()
255 else:
256 self._cptr = <void*><void_ptr>init_value.getPtr()
257 elif self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_HOST_POINTER,):
258 self._void = <void**><void_ptr>init_value
259 self._cptr = <void*>&self._void
260 elif self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_P2P_TOKENS,):
261 if self._is_getter:
262 self._token = _driver["CUDA_POINTER_ATTRIBUTE_P2P_TOKENS"]()
263 self._cptr = <void*><void_ptr>self._token.getPtr()
264 else:
265 self._cptr = <void*><void_ptr>init_value.getPtr()
266 elif self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_SYNC_MEMOPS,
267 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_MANAGED,
268 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE,
269 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MAPPED,):
270 self._bool = init_value
271 self._cptr = <void*>&self._bool
272 elif self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_BUFFER_ID,):
273 self._ull = init_value
274 self._cptr = <void*>&self._ull
275 elif self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_RANGE_SIZE,):
276 self._size = init_value
277 self._cptr = <void*>&self._size
278 elif self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MEMPOOL_HANDLE,):
279 if self._is_getter:
280 self._mempool = _driver["CUmemoryPool"]()
281 self._cptr = <void*><void_ptr>self._mempool.getPtr()
282 else:
283 self._cptr = <void*><void_ptr>init_value.getPtr()
284 else:
285 raise TypeError('Unsupported attribute: {}'.format(attr.name))
287 def __dealloc__(self):
288 pass
290 @property
291 def cptr(self):
292 return <void_ptr>self._cptr
294 def pyObj(self):
295 assert(self._is_getter == True)
296 if self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_CONTEXT,):
297 return self._ctx
298 elif self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MEMORY_TYPE,
299 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL,
300 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES,
301 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE,
302 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_ACCESS_FLAGS,):
303 return self._uint
304 elif self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_DEVICE_POINTER,
305 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_RANGE_START_ADDR,):
306 return self._devptr
307 elif self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_HOST_POINTER,):
308 return <void_ptr>self._void
309 elif self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_P2P_TOKENS,):
310 return self._token
311 elif self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_SYNC_MEMOPS,
312 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_MANAGED,
313 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE,
314 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MAPPED,):
315 return self._bool
316 elif self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_BUFFER_ID,):
317 return self._ull
318 elif self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_RANGE_SIZE,):
319 return self._size
320 elif self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MEMPOOL_HANDLE,):
321 return self._mempool
322 else:
323 raise TypeError('Unsupported attribute value: {}'.format(self._attr))
325cdef class _HelperCUgraphMem_attribute:
326 def __cinit__(self, attr, init_value, is_getter=False):
327 self._is_getter = is_getter
328 self._attr = attr.value
329 if self._attr in (cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_USED_MEM_CURRENT,
330 cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_USED_MEM_HIGH,
331 cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT,
332 cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH,):
333 if self._is_getter:
334 self._cuuint64_t_val = _driver["cuuint64_t"]()
335 self._cptr = <void*><void_ptr>self._cuuint64_t_val.getPtr()
336 else:
337 self._cptr = <void*><void_ptr>init_value.getPtr()
338 else:
339 raise TypeError('Unsupported attribute: {}'.format(attr.name))
341 def __dealloc__(self):
342 pass
344 @property
345 def cptr(self):
346 return <void_ptr>self._cptr
348 def pyObj(self):
349 assert(self._is_getter == True)
350 if self._attr in (cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_USED_MEM_CURRENT,
351 cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_USED_MEM_HIGH,
352 cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT,
353 cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH,):
354 return self._cuuint64_t_val
355 else:
356 raise TypeError('Unsupported attribute value: {}'.format(self._attr))
358cdef class _HelperCUjit_option:
359 def __cinit__(self, attr, init_value):
360 self._attr = attr.value
361 if self._attr in (cydriver.CUjit_option_enum.CU_JIT_MAX_REGISTERS,
362 cydriver.CUjit_option_enum.CU_JIT_THREADS_PER_BLOCK,
363 cydriver.CUjit_option_enum.CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES,
364 cydriver.CUjit_option_enum.CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES,
365 cydriver.CUjit_option_enum.CU_JIT_OPTIMIZATION_LEVEL,
366 cydriver.CUjit_option_enum.CU_JIT_GLOBAL_SYMBOL_COUNT,
367 cydriver.CUjit_option_enum.CU_JIT_TARGET_FROM_CUCONTEXT,
368 cydriver.CUjit_option_enum.CU_JIT_REFERENCED_KERNEL_COUNT,
369 cydriver.CUjit_option_enum.CU_JIT_REFERENCED_VARIABLE_COUNT,
370 cydriver.CUjit_option_enum.CU_JIT_MIN_CTA_PER_SM,
371 cydriver.CUjit_option_enum.CU_JIT_SPLIT_COMPILE,):
372 self._uint = init_value
373 self._cptr = <void*><void_ptr>self._uint
374 elif self._attr in (cydriver.CUjit_option_enum.CU_JIT_WALL_TIME,):
375 self._float = init_value
376 self._cptr = <void*><void_ptr>self._float
377 elif self._attr in (cydriver.CUjit_option_enum.CU_JIT_INFO_LOG_BUFFER,
378 cydriver.CUjit_option_enum.CU_JIT_ERROR_LOG_BUFFER):
379 self._charstar = init_value
380 self._cptr = <void*><void_ptr>self._charstar
381 elif self._attr in (cydriver.CUjit_option_enum.CU_JIT_TARGET,):
382 self._target = init_value.value
383 self._cptr = <void*><void_ptr>self._target
384 elif self._attr in (cydriver.CUjit_option_enum.CU_JIT_FALLBACK_STRATEGY,):
385 self._fallback = init_value.value
386 self._cptr = <void*><void_ptr>self._fallback
387 elif self._attr in (cydriver.CUjit_option_enum.CU_JIT_GENERATE_DEBUG_INFO,
388 cydriver.CUjit_option_enum.CU_JIT_LOG_VERBOSE,
389 cydriver.CUjit_option_enum.CU_JIT_GENERATE_LINE_INFO,
390 cydriver.CUjit_option_enum.CU_JIT_LTO,
391 cydriver.CUjit_option_enum.CU_JIT_FTZ,
392 cydriver.CUjit_option_enum.CU_JIT_PREC_DIV,
393 cydriver.CUjit_option_enum.CU_JIT_PREC_SQRT,
394 cydriver.CUjit_option_enum.CU_JIT_FMA,
395 cydriver.CUjit_option_enum.CU_JIT_OPTIMIZE_UNUSED_DEVICE_VARIABLES,):
396 self._int = init_value
397 self._cptr = <void*><void_ptr>self._int
398 elif self._attr in (cydriver.CUjit_option_enum.CU_JIT_CACHE_MODE,):
399 self._cacheMode = init_value.value
400 self._cptr = <void*><void_ptr>self._cacheMode
401 elif self._attr in (cydriver.CUjit_option_enum.CU_JIT_GLOBAL_SYMBOL_NAMES,
402 cydriver.CUjit_option_enum.CU_JIT_REFERENCED_KERNEL_NAMES,
403 cydriver.CUjit_option_enum.CU_JIT_REFERENCED_VARIABLE_NAMES,):
404 self._charstarstar = init_value
405 self._cptr = <void*>&self._charstarstar[0]
406 elif self._attr in (cydriver.CUjit_option_enum.CU_JIT_GLOBAL_SYMBOL_ADDRESSES,):
407 pylist = [_HelperInputVoidPtr(val) for val in init_value]
408 self._voidstarstar = _InputVoidPtrPtrHelper(pylist)
409 self._cptr = <void*><void_ptr>self._voidstarstar.cptr
410 else:
411 raise TypeError('Unsupported attribute: {}'.format(attr.name))
413 def __dealloc__(self):
414 pass
416 @property
417 def cptr(self):
418 return <void_ptr>self._cptr
420cdef class _HelperCudaJitOption:
421 def __cinit__(self, attr, init_value):
422 self._attr = attr.value
423 if self._attr in (cyruntime.cudaJitOption.cudaJitMaxRegisters,
424 cyruntime.cudaJitOption.cudaJitThreadsPerBlock,
425 cyruntime.cudaJitOption.cudaJitInfoLogBufferSizeBytes,
426 cyruntime.cudaJitOption.cudaJitErrorLogBufferSizeBytes,
427 cyruntime.cudaJitOption.cudaJitOptimizationLevel,
428 cyruntime.cudaJitOption.cudaJitMinCtaPerSm,):
429 self._uint = init_value
430 self._cptr = <void*><void_ptr>self._uint
431 elif self._attr in (cyruntime.cudaJitOption.cudaJitWallTime,):
432 self._float = init_value
433 self._cptr = <void*><void_ptr>self._float
434 elif self._attr in (cyruntime.cudaJitOption.cudaJitInfoLogBuffer,
435 cyruntime.cudaJitOption.cudaJitErrorLogBuffer):
436 self._charstar = init_value
437 self._cptr = <void*><void_ptr>self._charstar
438 elif self._attr in (cyruntime.cudaJitOption.cudaJitFallbackStrategy,):
439 self._fallback = init_value.value
440 self._cptr = <void*><void_ptr>self._fallback
441 elif self._attr in (cyruntime.cudaJitOption.cudaJitGenerateDebugInfo,
442 cyruntime.cudaJitOption.cudaJitLogVerbose,
443 cyruntime.cudaJitOption.cudaJitGenerateLineInfo,
444 cyruntime.cudaJitOption.cudaJitPositionIndependentCode,
445 cyruntime.cudaJitOption.cudaJitMaxThreadsPerBlock,
446 cyruntime.cudaJitOption.cudaJitOverrideDirectiveValues,):
447 self._int = init_value
448 self._cptr = <void*><void_ptr>self._int
449 elif self._attr in (cyruntime.cudaJitOption.cudaJitCacheMode,):
450 self._cacheMode = init_value.value
451 self._cptr = <void*><void_ptr>self._cacheMode
452 else:
453 raise TypeError('Unsupported attribute: {}'.format(attr.name))
455 def __dealloc__(self):
456 pass
458 @property
459 def cptr(self):
460 return <void_ptr>self._cptr
462cdef class _HelperCUlibraryOption:
463 def __cinit__(self, attr, init_value):
464 self._attr = attr.value
465 if False:
466 pass
467 elif self._attr in (cydriver.CUlibraryOption_enum.CU_LIBRARY_HOST_UNIVERSAL_FUNCTION_AND_DATA_TABLE,):
468 self._cptr = <void*><void_ptr>init_value.getPtr()
469 elif self._attr in (cydriver.CUlibraryOption_enum.CU_LIBRARY_BINARY_IS_PRESERVED,):
470 self._uint = init_value
471 self._cptr = <void*><void_ptr>self._uint
472 else:
473 raise TypeError('Unsupported attribute: {}'.format(attr.name))
475 def __dealloc__(self):
476 pass
478 @property
479 def cptr(self):
480 return <void_ptr>self._cptr
482cdef class _HelperCudaLibraryOption:
483 def __cinit__(self, attr, init_value):
484 self._attr = attr.value
485 if False:
486 pass
487 elif self._attr in (cyruntime.cudaLibraryOption.cudaLibraryHostUniversalFunctionAndDataTable,):
488 self._cptr = <void*><void_ptr>init_value.getPtr()
489 elif self._attr in (cyruntime.cudaLibraryOption.cudaLibraryBinaryIsPreserved,):
490 self._uint = init_value
491 self._cptr = <void*><void_ptr>self._uint
492 else:
493 raise TypeError('Unsupported attribute: {}'.format(attr.name))
495 def __dealloc__(self):
496 pass
498 @property
499 def cptr(self):
500 return <void_ptr>self._cptr
502cdef class _HelperCUmemAllocationHandleType:
503 def __cinit__(self, attr):
504 self._type = attr.value
505 if False:
506 pass
507 elif self._type in (cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_NONE,):
508 self._cptr = <void*>&self._int
509 elif self._type in (cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR,):
510 self._cptr = <void*>&self._int
511 elif self._type in (cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_WIN32,):
512 self._cptr = <void*>&self._handle
513 elif self._type in (cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_WIN32_KMT,):
514 self._cptr = <void*>&self._d3dkmt_handle
515 elif self._type in (cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_FABRIC,):
516 self._mem_fabric_handle = _driver["CUmemFabricHandle"]()
517 self._cptr = <void*><void_ptr>self._mem_fabric_handle.getPtr()
518 else:
519 raise TypeError('Unsupported attribute: {}'.format(attr.name))
521 def __dealloc__(self):
522 pass
524 @property
525 def cptr(self):
526 return <void_ptr>self._cptr
528 def pyObj(self):
529 if False:
530 pass
531 elif self._type in (cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_NONE,):
532 return self._int
533 elif self._type in (cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR,):
534 return self._int
535 elif self._type in (cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_WIN32,):
536 return <void_ptr>self._handle
537 elif self._type in (cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_WIN32_KMT,):
538 return self._d3dkmt_handle
539 elif self._type in (cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_FABRIC,):
540 return self._mem_fabric_handle
541 else:
542 raise TypeError('Unsupported attribute: {}'.format(self._type))
544cdef class _InputVoidPtrPtrHelper:
545 def __cinit__(self, lst):
546 self._cptr = <void**>_callocWrapper(len(lst), sizeof(void*))
547 for idx in range(len(lst)):
548 self._cptr[idx] = <void*><void_ptr>lst[idx].cptr
550 def __dealloc__(self):
551 free(self._cptr)
553 @property
554 def cptr(self):
555 return <void_ptr>self._cptr
557cdef class _HelperCUcoredumpSettings:
558 def __cinit__(self, attr, init_value, is_getter=False):
559 self._is_getter = is_getter
560 self._attrib = attr.value
561 if self._attrib in (cydriver.CUcoredumpSettings_enum.CU_COREDUMP_FILE,
562 cydriver.CUcoredumpSettings_enum.CU_COREDUMP_PIPE,):
563 if self._is_getter:
564 self._charstar = <char*>_callocWrapper(1024, 1)
565 self._cptr = <void*><void_ptr>self._charstar
566 self._size = 1024
567 else:
568 self._charstar = init_value
569 self._cptr = <void*><void_ptr>self._charstar
570 self._size = len(init_value)
571 elif self._attrib in (cydriver.CUcoredumpSettings_enum.CU_COREDUMP_ENABLE_ON_EXCEPTION,
572 cydriver.CUcoredumpSettings_enum.CU_COREDUMP_TRIGGER_HOST,
573 cydriver.CUcoredumpSettings_enum.CU_COREDUMP_LIGHTWEIGHT,
574 cydriver.CUcoredumpSettings_enum.CU_COREDUMP_ENABLE_USER_TRIGGER,):
575 if self._is_getter == False:
576 self._bool = init_value
578 self._cptr = <void*>&self._bool
579 self._size = 1
580 else:
581 raise TypeError('Unsupported attribute: {}'.format(attr.name))
583 def __dealloc__(self):
584 pass
586 @property
587 def cptr(self):
588 return <void_ptr>self._cptr
590 def size(self):
591 return self._size
593 def pyObj(self):
594 assert(self._is_getter == True)
595 if self._attrib in (cydriver.CUcoredumpSettings_enum.CU_COREDUMP_FILE,
596 cydriver.CUcoredumpSettings_enum.CU_COREDUMP_PIPE,):
597 return self._charstar
598 elif self._attrib in (cydriver.CUcoredumpSettings_enum.CU_COREDUMP_ENABLE_ON_EXCEPTION,
599 cydriver.CUcoredumpSettings_enum.CU_COREDUMP_TRIGGER_HOST,
600 cydriver.CUcoredumpSettings_enum.CU_COREDUMP_LIGHTWEIGHT,
601 cydriver.CUcoredumpSettings_enum.CU_COREDUMP_ENABLE_USER_TRIGGER,):
602 return self._bool
603 else:
604 raise TypeError('Unsupported attribute value: {}'.format(self._attrib))