Coverage for cuda / bindings / _lib / utils.pxi: 56.38%

376 statements  

« prev     ^ index     » next       coverage.py v7.13.4, created at 2026-03-08 01:07 +0000

1# SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 

2# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE 

3  

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 cuda.bindings._internal._fast_enum import FastEnum as _FastEnum 

10import ctypes as _ctypes 

11cimport cuda.bindings.cydriver as cydriver 

12cimport cuda.bindings._lib.param_packer as param_packer 

13  

14cdef void* _callocWrapper(length, size): 

15 cdef void* out = calloc(length, size) 1fsjakdbec

16 if out is NULL: 1fsjakdbec

17 raise MemoryError('Failed to allocated length x size memory: {}x{}'.format(length, size)) 

18 return out 1fsjakdbec

19  

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 } 

39  

40 max_param_size = max(_ctypes.sizeof(max(_HelperKernelParams.supported_types, key=lambda t:_ctypes.sizeof(t))), sizeof(void_ptr)) 

41  

42 def __cinit__(self, kernelParams): 

43 self._pyobj_acquired = False 1dblnmiec

44 self._malloc_list_created = False 1dblnmiec

45 if kernelParams is None: 1dblnmiec

46 self._ckernelParams = NULL 1i

47 elif isinstance(kernelParams, (int)): 1dblnmiec

48 # Easy run, user gave us an already configured void** address 

49 self._ckernelParams = <void**><void_ptr>kernelParams 1n

50 elif PyObject_CheckBuffer(kernelParams): 1dblmiec

51 # Easy run, get address from Python Buffer Protocol 

52 err_buffer = PyObject_GetBuffer(kernelParams, &self._pybuffer, PyBUF_SIMPLE | PyBUF_ANY_CONTIGUOUS) 1lm

53 if err_buffer == -1: 1lm

54 raise RuntimeError("Argument 'kernelParams' failed to retrieve buffer through Buffer Protocol") 

55 self._pyobj_acquired = True 1lm

56 self._ckernelParams = <void**><void_ptr>self._pybuffer.buf 1lm

57 elif isinstance(kernelParams, (tuple)) and len(kernelParams) == 2 and isinstance(kernelParams[0], (tuple)) and isinstance(kernelParams[1], (tuple)): 1dbiec

58 # Hard run, construct and fill out contigues memory using provided kernel values and types based 

59 if len(kernelParams[0]) != len(kernelParams[1]): 1dbiec

60 raise TypeError("Argument 'kernelParams' has tuples with different length") 

61 if len(kernelParams[0]) != 0: 1dbiec

62 self._length = len(kernelParams[0]) 1dbec

63 self._ckernelParams = <void**>_callocWrapper(len(kernelParams[0]), sizeof(void*)) 1dbec

64 self._ckernelParamsData = <char*>_callocWrapper(len(kernelParams[0]), _HelperKernelParams.max_param_size) 1dbec

65 self._malloc_list_created = True 1dbec

66  

67 idx = 0 1dbiec

68 data_idx = 0 1dbiec

69 for value, ctype in zip(kernelParams[0], kernelParams[1]): 1dbiec

70 if ctype is None: 1dbec

71 # special cases for None 

72 if callable(getattr(value, 'getPtr', None)): 1dbec

73 self._ckernelParams[idx] = <void*><void_ptr>value.getPtr() 1dbc

74 elif isinstance(value, (_ctypes.Structure)): 1ec

75 self._ckernelParams[idx] = <void*><void_ptr>_ctypes.addressof(value) 1e

76 elif isinstance(value, (_FastEnum)): 1c

77 self._ckernelParams[idx] = &(self._ckernelParamsData[data_idx]) 1c

78 (<int*>self._ckernelParams[idx])[0] = value.value 1c

79 data_idx += sizeof(int) 1c

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: 1dbec

83 self._ckernelParams[idx] = &(self._ckernelParamsData[data_idx]) 1db

84  

85 # handle case where a float is passed as a double 

86 if ctype == _ctypes.c_double and isinstance(value, _ctypes.c_float): 1db

87 value = ctype(value.value) 1d

88 if not isinstance(value, ctype): # make it a ctype 1db

89 size = param_packer.feed(self._ckernelParams[idx], value, ctype) 1b

90 if size == 0: # feed failed 1b

91 value = ctype(value) 1b

92 size = _ctypes.sizeof(ctype) 1b

93 addr = <void*>(<void_ptr>_ctypes.addressof(value)) 1b

94 memcpy(self._ckernelParams[idx], addr, size) 1b

95 else: 

96 size = _ctypes.sizeof(ctype) 1d

97 addr = <void*>(<void_ptr>_ctypes.addressof(value)) 1d

98 memcpy(self._ckernelParams[idx], addr, size) 1d

99 data_idx += size 1db

100 elif ctype == _ctypes.c_void_p: 1dbec

101 # special cases for void_p 

102 if isinstance(value, (int, _ctypes.c_void_p)): 1dbec

103 self._ckernelParams[idx] = &(self._ckernelParamsData[data_idx]) 1dbec

104 (<void_ptr*>self._ckernelParams[idx])[0] = value.value if isinstance(value, (_ctypes.c_void_p)) else value 1dbec

105 data_idx += sizeof(void_ptr) 1dbec

106 elif callable(getattr(value, 'getPtr', None)): 1c

107 self._ckernelParams[idx] = &(self._ckernelParamsData[data_idx]) 1c

108 (<void_ptr*>self._ckernelParams[idx])[0] = value.getPtr() 1c

109 data_idx += sizeof(void_ptr) 1c

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 1dbec

115 else: 

116 raise TypeError("Argument 'kernelParams' is not a valid type: tuple[tuple[Any, ...], tuple[Any, ...]] or PyObject implimenting Buffer Protocol or Int") 

117  

118 def __dealloc__(self): 

119 if self._pyobj_acquired is True: 1dblnmiec

120 PyBuffer_Release(&self._pybuffer) 1lm

121 if self._malloc_list_created is True: 1dblnmiec

122 free(self._ckernelParams) 1dbec

123 free(self._ckernelParamsData) 1dbec

124  

125 @property 

126 def ckernelParams(self): 

127 return <void_ptr>self._ckernelParams 1dblnmiec

128  

129cdef class _HelperInputVoidPtr: 

130 def __cinit__(self, ptr): 

131 self._cptr = _helper_input_void_ptr(ptr, &self._helper) 1pqIJrKLMN

132  

133 def __dealloc__(self): 

134 _helper_input_void_ptr_free(&self._helper) 1pqIJrKLMN

135  

136 @property 

137 def cptr(self): 

138 return <void_ptr>self._cptr  1pqIJrKLMN

139  

140  

141cdef void * _helper_input_void_ptr(ptr, _HelperInputVoidPtrStruct *helper): 

142 helper[0]._pybuffer.buf = NULL 2O P Q R S T U V W X Y Z 0 1 2 3 4 5 6 7 8 9 ! # $ % ' p s t q I J u r v w x y z A B C D E F ( ) * G + , - . H d b l n m i e c / : ; = ? @ [ ] ^ _ ` { | } ~ abbbcbdbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbIbJbKbLbMbNbObPbQbRbSbTbUbVbWbXbYbZb0b1b2b3b4b5b6bK L M N 7b

143 try: 2O P Q R S T U V W X Y Z 0 1 2 3 4 5 6 7 8 9 ! # $ % ' p s t q I J u r v w x y z A B C D E F ( ) * G + , - . H d b l n m i e c / : ; = ? @ [ ] ^ _ ` { | } ~ abbbcbdbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbIbJbKbLbMbNbObPbQbRbSbTbUbVbWbXbYbZb0b1b2b3b4b5b6bK L M N 7b

144 return <void *><void_ptr>ptr  2O P Q R S T U V W X Y Z 0 1 2 3 4 5 6 7 8 9 ! # $ % ' p s t q I J u r v w x y z A B C D E F ( ) * G + , - . H d b l n m i e c / : ; = ? @ [ ] ^ _ ` { | } ~ abbbcbdbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbIbJbKbLbMbNbObPbQbRbSbTbUbVbWbXbYbZb0b1b2b3b4b5b6bK L M N 7b

145 except: 1ptqurvwxyzABCDEFGHdblnmiec

146 if ptr is None: 1ptqurvwxyzABCDEFGHdblnmiec

147 return NULL 

148 elif PyObject_CheckBuffer(ptr): 1ptqurvwxyzABCDEFGHdblnmiec

149 # Easy run, get address from Python Buffer Protocol 

150 err_buffer = PyObject_GetBuffer(ptr, &helper[0]._pybuffer, PyBUF_SIMPLE | PyBUF_ANY_CONTIGUOUS) 1ptqurvwxyzABCDEFGHdblnmiec

151 if err_buffer == -1: 1ptqurvwxyzABCDEFGHdblnmiec

152 raise RuntimeError("Failed to retrieve buffer through Buffer Protocol") 

153 return <void*><void_ptr>(helper[0]._pybuffer.buf) 1ptqurvwxyzABCDEFGHdblnmiec

154 else: 

155 raise TypeError("Provided argument is of type {} but expected Type {}, {} or object with Buffer Protocol".format(type(ptr), type(None), type(int))) 

156  

157  

158cdef class _HelperCUmemPool_attribute: 

159 def __cinit__(self, attr, init_value, is_getter=False): 

160 self._is_getter = is_getter 1gh

161 self._attr = attr.value 1gh

162 if self._attr in (cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_FOLLOW_EVENT_DEPENDENCIES, 1gh

163 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_ALLOW_OPPORTUNISTIC, 1gh

164 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_ALLOW_INTERNAL_DEPENDENCIES,): 

165 self._int_val = init_value 1gh

166 self._cptr = <void*>&self._int_val 1gh

167 elif self._attr in (cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RELEASE_THRESHOLD, 1gh

168 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RESERVED_MEM_CURRENT, 1gh

169 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RESERVED_MEM_HIGH, 1gh

170 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_USED_MEM_CURRENT, 1gh

171 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_USED_MEM_HIGH,): 

172 if self._is_getter: 1gh

173 self._cuuint64_t_val = _driver["cuuint64_t"]() 1gh

174 self._cptr = <void*><void_ptr>self._cuuint64_t_val.getPtr() 1gh

175 else: 

176 self._cptr = <void*><void_ptr>init_value.getPtr() 1gh

177 else: 

178 raise TypeError('Unsupported attribute: {}'.format(attr.name)) 

179  

180 def __dealloc__(self): 

181 pass 1gh

182  

183 @property 

184 def cptr(self): 

185 return <void_ptr>self._cptr 1gh

186  

187 def pyObj(self): 

188 assert(self._is_getter == True) 1gh

189 if self._attr in (cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_FOLLOW_EVENT_DEPENDENCIES, 1gh

190 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_ALLOW_OPPORTUNISTIC, 1gh

191 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_ALLOW_INTERNAL_DEPENDENCIES,): 

192 return self._int_val 1gh

193 elif self._attr in (cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RELEASE_THRESHOLD, 1gh

194 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RESERVED_MEM_CURRENT, 1gh

195 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RESERVED_MEM_HIGH, 1gh

196 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_USED_MEM_CURRENT, 1gh

197 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_USED_MEM_HIGH,): 

198 return self._cuuint64_t_val 1gh

199 else: 

200 raise TypeError('Unsupported attribute value: {}'.format(self._attr)) 

201  

202cdef class _HelperCUmem_range_attribute: 

203 def __cinit__(self, attr, data_size): 

204 self._data_size = data_size 1j

205 self._attr = attr.value 1j

206 if self._attr in (cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY, 1j

207 cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION, 1j

208 cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION,): 

209 self._cptr = <void*>&self._int_val 1j

210 elif self._attr in (cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY,): 

211 self._cptr = _callocWrapper(1, self._data_size) 1j

212 self._int_val_list = <int*>self._cptr 1j

213 else: 

214 raise TypeError('Unsupported attribute: {}'.format(attr.name)) 

215  

216 def __dealloc__(self): 

217 if self._attr in (cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY,): 1j

218 free(self._cptr) 1j

219  

220 @property 

221 def cptr(self): 

222 return <void_ptr>self._cptr 1j

223  

224 def pyObj(self): 

225 if self._attr in (cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY, 1j

226 cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION, 1j

227 cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION,): 

228 return self._int_val 1j

229 elif self._attr in (cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY,): 

230 return [self._int_val_list[idx] for idx in range(int(self._data_size/4))] 1j

231 else: 

232 raise TypeError('Unsupported attribute value: {}'.format(self._attr)) 

233  

234cdef class _HelperCUpointer_attribute: 

235 def __cinit__(self, attr, init_value, is_getter=False): 

236 self._is_getter = is_getter 1ak

237 self._attr = attr.value 1ak

238 if self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_CONTEXT,): 1ak

239 if self._is_getter: 1a

240 self._ctx = _driver["CUcontext"]() 1a

241 self._cptr = <void*><void_ptr>self._ctx.getPtr() 1a

242 else: 

243 self._cptr = <void*><void_ptr>init_value.getPtr() 

244 elif self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MEMORY_TYPE, 1a

245 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES, 1a

246 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE, 1a

247 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_ACCESS_FLAGS,): 

248 self._uint = init_value 1a

249 self._cptr = <void*>&self._uint 1a

250 elif self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL,): 

251 self._int = init_value 1ak

252 self._cptr = <void*>&self._int 1ak

253 elif self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_DEVICE_POINTER, 1a

254 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_RANGE_START_ADDR,): 

255 if self._is_getter: 1a

256 self._devptr = _driver["CUdeviceptr"]() 1a

257 self._cptr = <void*><void_ptr>self._devptr.getPtr() 1a

258 else: 

259 self._cptr = <void*><void_ptr>init_value.getPtr() 

260 elif self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_HOST_POINTER,): 

261 self._void = <void**><void_ptr>init_value 1a

262 self._cptr = <void*>&self._void 1a

263 elif self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_P2P_TOKENS,): 

264 if self._is_getter: 

265 self._token = _driver["CUDA_POINTER_ATTRIBUTE_P2P_TOKENS"]() 

266 self._cptr = <void*><void_ptr>self._token.getPtr() 

267 else: 

268 self._cptr = <void*><void_ptr>init_value.getPtr() 

269 elif self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_SYNC_MEMOPS, 1a

270 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_MANAGED, 1a

271 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE, 1a

272 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MAPPED,): 

273 self._bool = init_value 1a

274 self._cptr = <void*>&self._bool 1a

275 elif self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_BUFFER_ID,): 

276 self._ull = init_value 1a

277 self._cptr = <void*>&self._ull 1a

278 elif self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_RANGE_SIZE,): 

279 self._size = init_value 1a

280 self._cptr = <void*>&self._size 1a

281 elif self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MEMPOOL_HANDLE,): 

282 if self._is_getter: 1a

283 self._mempool = _driver["CUmemoryPool"]() 1a

284 self._cptr = <void*><void_ptr>self._mempool.getPtr() 1a

285 else: 

286 self._cptr = <void*><void_ptr>init_value.getPtr() 

287 else: 

288 raise TypeError('Unsupported attribute: {}'.format(attr.name)) 

289  

290 def __dealloc__(self): 

291 pass 1ak

292  

293 @property 

294 def cptr(self): 

295 return <void_ptr>self._cptr 1ak

296  

297 def pyObj(self): 

298 assert(self._is_getter == True) 1ak

299 if self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_CONTEXT,): 1ak

300 return self._ctx 1a

301 elif self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MEMORY_TYPE, 1a

302 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL, 1ak

303 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES, 1ak

304 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE, 1ak

305 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_ACCESS_FLAGS,): 

306 return self._uint 1ak

307 elif self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_DEVICE_POINTER, 1a

308 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_RANGE_START_ADDR,): 

309 return self._devptr 1a

310 elif self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_HOST_POINTER,): 

311 return <void_ptr>self._void 1a

312 elif self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_P2P_TOKENS,): 

313 return self._token 

314 elif self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_SYNC_MEMOPS, 1a

315 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_MANAGED, 1a

316 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE, 1a

317 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MAPPED,): 

318 return self._bool 1a

319 elif self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_BUFFER_ID,): 

320 return self._ull 1a

321 elif self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_RANGE_SIZE,): 

322 return self._size 1a

323 elif self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MEMPOOL_HANDLE,): 

324 return self._mempool 1a

325 else: 

326 raise TypeError('Unsupported attribute value: {}'.format(self._attr)) 

327  

328cdef class _HelperCUgraphMem_attribute: 

329 def __cinit__(self, attr, init_value, is_getter=False): 

330 self._is_getter = is_getter 1o

331 self._attr = attr.value 1o

332 if self._attr in (cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_USED_MEM_CURRENT, 1o

333 cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_USED_MEM_HIGH, 1o

334 cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT, 1o

335 cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH,): 

336 if self._is_getter: 1o

337 self._cuuint64_t_val = _driver["cuuint64_t"]() 1o

338 self._cptr = <void*><void_ptr>self._cuuint64_t_val.getPtr() 1o

339 else: 

340 self._cptr = <void*><void_ptr>init_value.getPtr() 

341 else: 

342 raise TypeError('Unsupported attribute: {}'.format(attr.name)) 

343  

344 def __dealloc__(self): 

345 pass 1o

346  

347 @property 

348 def cptr(self): 

349 return <void_ptr>self._cptr 1o

350  

351 def pyObj(self): 

352 assert(self._is_getter == True) 1o

353 if self._attr in (cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_USED_MEM_CURRENT, 1o

354 cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_USED_MEM_HIGH, 1o

355 cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT, 1o

356 cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH,): 

357 return self._cuuint64_t_val 1o

358 else: 

359 raise TypeError('Unsupported attribute value: {}'.format(self._attr)) 

360  

361cdef class _HelperCUjit_option: 

362 def __cinit__(self, attr, init_value): 

363 self._attr = attr.value 

364 if self._attr in (cydriver.CUjit_option_enum.CU_JIT_MAX_REGISTERS, 

365 cydriver.CUjit_option_enum.CU_JIT_THREADS_PER_BLOCK, 

366 cydriver.CUjit_option_enum.CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES, 

367 cydriver.CUjit_option_enum.CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES, 

368 cydriver.CUjit_option_enum.CU_JIT_OPTIMIZATION_LEVEL, 

369 cydriver.CUjit_option_enum.CU_JIT_GLOBAL_SYMBOL_COUNT, 

370 cydriver.CUjit_option_enum.CU_JIT_TARGET_FROM_CUCONTEXT, 

371 cydriver.CUjit_option_enum.CU_JIT_REFERENCED_KERNEL_COUNT, 

372 cydriver.CUjit_option_enum.CU_JIT_REFERENCED_VARIABLE_COUNT, 

373 cydriver.CUjit_option_enum.CU_JIT_MIN_CTA_PER_SM, 

374 cydriver.CUjit_option_enum.CU_JIT_SPLIT_COMPILE,): 

375 self._uint = init_value 

376 self._cptr = <void*><void_ptr>self._uint 

377 elif self._attr in (cydriver.CUjit_option_enum.CU_JIT_WALL_TIME,): 

378 self._float = init_value 

379 self._cptr = <void*><void_ptr>self._float 

380 elif self._attr in (cydriver.CUjit_option_enum.CU_JIT_INFO_LOG_BUFFER, 

381 cydriver.CUjit_option_enum.CU_JIT_ERROR_LOG_BUFFER): 

382 self._charstar = init_value 

383 self._cptr = <void*><void_ptr>self._charstar 

384 elif self._attr in (cydriver.CUjit_option_enum.CU_JIT_TARGET,): 

385 self._target = init_value.value 

386 self._cptr = <void*><void_ptr>self._target 

387 elif self._attr in (cydriver.CUjit_option_enum.CU_JIT_FALLBACK_STRATEGY,): 

388 self._fallback = init_value.value 

389 self._cptr = <void*><void_ptr>self._fallback 

390 elif self._attr in (cydriver.CUjit_option_enum.CU_JIT_GENERATE_DEBUG_INFO, 

391 cydriver.CUjit_option_enum.CU_JIT_LOG_VERBOSE, 

392 cydriver.CUjit_option_enum.CU_JIT_GENERATE_LINE_INFO, 

393 cydriver.CUjit_option_enum.CU_JIT_LTO, 

394 cydriver.CUjit_option_enum.CU_JIT_FTZ, 

395 cydriver.CUjit_option_enum.CU_JIT_PREC_DIV, 

396 cydriver.CUjit_option_enum.CU_JIT_PREC_SQRT, 

397 cydriver.CUjit_option_enum.CU_JIT_FMA, 

398 cydriver.CUjit_option_enum.CU_JIT_OPTIMIZE_UNUSED_DEVICE_VARIABLES,): 

399 self._int = init_value 

400 self._cptr = <void*><void_ptr>self._int 

401 elif self._attr in (cydriver.CUjit_option_enum.CU_JIT_CACHE_MODE,): 

402 self._cacheMode = init_value.value 

403 self._cptr = <void*><void_ptr>self._cacheMode 

404 elif self._attr in (cydriver.CUjit_option_enum.CU_JIT_GLOBAL_SYMBOL_NAMES, 

405 cydriver.CUjit_option_enum.CU_JIT_REFERENCED_KERNEL_NAMES, 

406 cydriver.CUjit_option_enum.CU_JIT_REFERENCED_VARIABLE_NAMES,): 

407 self._charstarstar = init_value 

408 self._cptr = <void*>&self._charstarstar[0] 

409 elif self._attr in (cydriver.CUjit_option_enum.CU_JIT_GLOBAL_SYMBOL_ADDRESSES,): 

410 pylist = [_HelperInputVoidPtr(val) for val in init_value] 

411 self._voidstarstar = _InputVoidPtrPtrHelper(pylist) 

412 self._cptr = <void*><void_ptr>self._voidstarstar.cptr 

413 else: 

414 raise TypeError('Unsupported attribute: {}'.format(attr.name)) 

415  

416 def __dealloc__(self): 

417 pass 

418  

419 @property 

420 def cptr(self): 

421 return <void_ptr>self._cptr 

422  

423cdef class _HelperCudaJitOption: 

424 def __cinit__(self, attr, init_value): 

425 self._attr = attr.value 

426 if self._attr in (cyruntime.cudaJitOption.cudaJitMaxRegisters, 

427 cyruntime.cudaJitOption.cudaJitThreadsPerBlock, 

428 cyruntime.cudaJitOption.cudaJitInfoLogBufferSizeBytes, 

429 cyruntime.cudaJitOption.cudaJitErrorLogBufferSizeBytes, 

430 cyruntime.cudaJitOption.cudaJitOptimizationLevel, 

431 cyruntime.cudaJitOption.cudaJitMinCtaPerSm,): 

432 self._uint = init_value 

433 self._cptr = <void*><void_ptr>self._uint 

434 elif self._attr in (cyruntime.cudaJitOption.cudaJitWallTime,): 

435 self._float = init_value 

436 self._cptr = <void*><void_ptr>self._float 

437 elif self._attr in (cyruntime.cudaJitOption.cudaJitInfoLogBuffer, 

438 cyruntime.cudaJitOption.cudaJitErrorLogBuffer): 

439 self._charstar = init_value 

440 self._cptr = <void*><void_ptr>self._charstar 

441 elif self._attr in (cyruntime.cudaJitOption.cudaJitFallbackStrategy,): 

442 self._fallback = init_value.value 

443 self._cptr = <void*><void_ptr>self._fallback 

444 elif self._attr in (cyruntime.cudaJitOption.cudaJitGenerateDebugInfo, 

445 cyruntime.cudaJitOption.cudaJitLogVerbose, 

446 cyruntime.cudaJitOption.cudaJitGenerateLineInfo, 

447 cyruntime.cudaJitOption.cudaJitPositionIndependentCode, 

448 cyruntime.cudaJitOption.cudaJitMaxThreadsPerBlock, 

449 cyruntime.cudaJitOption.cudaJitOverrideDirectiveValues,): 

450 self._int = init_value 

451 self._cptr = <void*><void_ptr>self._int 

452 elif self._attr in (cyruntime.cudaJitOption.cudaJitCacheMode,): 

453 self._cacheMode = init_value.value 

454 self._cptr = <void*><void_ptr>self._cacheMode 

455 else: 

456 raise TypeError('Unsupported attribute: {}'.format(attr.name)) 

457  

458 def __dealloc__(self): 

459 pass 

460  

461 @property 

462 def cptr(self): 

463 return <void_ptr>self._cptr 

464  

465cdef class _HelperCUlibraryOption: 

466 def __cinit__(self, attr, init_value): 

467 self._attr = attr.value 

468 if False: 

469 pass 

470 elif self._attr in (cydriver.CUlibraryOption_enum.CU_LIBRARY_HOST_UNIVERSAL_FUNCTION_AND_DATA_TABLE,): 

471 self._cptr = <void*><void_ptr>init_value.getPtr() 

472 elif self._attr in (cydriver.CUlibraryOption_enum.CU_LIBRARY_BINARY_IS_PRESERVED,): 

473 self._uint = init_value 

474 self._cptr = <void*><void_ptr>self._uint 

475 else: 

476 raise TypeError('Unsupported attribute: {}'.format(attr.name)) 

477  

478 def __dealloc__(self): 

479 pass 

480  

481 @property 

482 def cptr(self): 

483 return <void_ptr>self._cptr 

484  

485cdef class _HelperCudaLibraryOption: 

486 def __cinit__(self, attr, init_value): 

487 self._attr = attr.value 

488 if False: 

489 pass 

490 elif self._attr in (cyruntime.cudaLibraryOption.cudaLibraryHostUniversalFunctionAndDataTable,): 

491 self._cptr = <void*><void_ptr>init_value.getPtr() 

492 elif self._attr in (cyruntime.cudaLibraryOption.cudaLibraryBinaryIsPreserved,): 

493 self._uint = init_value 

494 self._cptr = <void*><void_ptr>self._uint 

495 else: 

496 raise TypeError('Unsupported attribute: {}'.format(attr.name)) 

497  

498 def __dealloc__(self): 

499 pass 

500  

501 @property 

502 def cptr(self): 

503 return <void_ptr>self._cptr 

504  

505cdef class _HelperCUmemAllocationHandleType: 

506 def __cinit__(self, attr): 

507 self._type = attr.value 

508 if False: 

509 pass 

510 elif self._type in (cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_NONE,): 

511 self._cptr = <void*>&self._int 

512 elif self._type in (cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR,): 

513 self._cptr = <void*>&self._int 

514 elif self._type in (cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_WIN32,): 

515 self._cptr = <void*>&self._handle 

516 elif self._type in (cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_WIN32_KMT,): 

517 self._cptr = <void*>&self._d3dkmt_handle 

518 elif self._type in (cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_FABRIC,): 

519 self._mem_fabric_handle = _driver["CUmemFabricHandle"]() 

520 self._cptr = <void*><void_ptr>self._mem_fabric_handle.getPtr() 

521 else: 

522 raise TypeError('Unsupported attribute: {}'.format(attr.name)) 

523  

524 def __dealloc__(self): 

525 pass 

526  

527 @property 

528 def cptr(self): 

529 return <void_ptr>self._cptr 

530  

531 def pyObj(self): 

532 if False: 

533 pass 

534 elif self._type in (cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_NONE,): 

535 return self._int 

536 elif self._type in (cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR,): 

537 return self._int 

538 elif self._type in (cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_WIN32,): 

539 return <void_ptr>self._handle 

540 elif self._type in (cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_WIN32_KMT,): 

541 return self._d3dkmt_handle 

542 elif self._type in (cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_FABRIC,): 

543 return self._mem_fabric_handle 

544 else: 

545 raise TypeError('Unsupported attribute: {}'.format(self._type)) 

546  

547cdef class _InputVoidPtrPtrHelper: 

548 def __cinit__(self, lst): 

549 # Hold onto references to the original buffers so they 

550 # won't be free'd behind our back 

551 self._references = lst 1sjak

552 self._cptr = <void**>_callocWrapper(len(lst), sizeof(void*)) 1sjak

553 for idx in range(len(lst)): 1sjak

554 self._cptr[idx] = <void*><void_ptr>lst[idx].cptr 1jak

555  

556 def __dealloc__(self): 

557 free(self._cptr) 1sjak

558  

559 @property 

560 def cptr(self): 

561 return <void_ptr>self._cptr 1sjak

562  

563cdef class _HelperCUcoredumpSettings: 

564 def __cinit__(self, attr, init_value, is_getter=False): 

565 self._is_getter = is_getter 1f

566 self._attrib = attr.value 1f

567 if self._attrib in (cydriver.CUcoredumpSettings_enum.CU_COREDUMP_FILE, 1f

568 cydriver.CUcoredumpSettings_enum.CU_COREDUMP_PIPE,): 

569 if self._is_getter: 1f

570 self._charstar = <char*>_callocWrapper(1024, 1) 1f

571 self._cptr = <void*><void_ptr>self._charstar 1f

572 self._size = 1024 1f

573 else: 

574 self._charstar = init_value 1f

575 self._cptr = <void*><void_ptr>self._charstar 1f

576 self._size = len(init_value) 1f

577 elif self._attrib in (cydriver.CUcoredumpSettings_enum.CU_COREDUMP_ENABLE_ON_EXCEPTION, 

578 cydriver.CUcoredumpSettings_enum.CU_COREDUMP_TRIGGER_HOST, 1f

579 cydriver.CUcoredumpSettings_enum.CU_COREDUMP_LIGHTWEIGHT, 1f

580 cydriver.CUcoredumpSettings_enum.CU_COREDUMP_ENABLE_USER_TRIGGER,): 

581 if self._is_getter == False: 1f

582 self._bool = init_value 1f

583  

584 self._cptr = <void*>&self._bool 1f

585 self._size = 1 1f

586 else: 

587 raise TypeError('Unsupported attribute: {}'.format(attr.name)) 

588  

589 def __dealloc__(self): 

590 pass 1f

591  

592 @property 

593 def cptr(self): 

594 return <void_ptr>self._cptr 1f

595  

596 def size(self): 

597 return self._size 1f

598  

599 def pyObj(self): 

600 assert(self._is_getter == True) 1f

601 if self._attrib in (cydriver.CUcoredumpSettings_enum.CU_COREDUMP_FILE, 1f

602 cydriver.CUcoredumpSettings_enum.CU_COREDUMP_PIPE,): 

603 return self._charstar 1f

604 elif self._attrib in (cydriver.CUcoredumpSettings_enum.CU_COREDUMP_ENABLE_ON_EXCEPTION, 

605 cydriver.CUcoredumpSettings_enum.CU_COREDUMP_TRIGGER_HOST, 1f

606 cydriver.CUcoredumpSettings_enum.CU_COREDUMP_LIGHTWEIGHT, 1f

607 cydriver.CUcoredumpSettings_enum.CU_COREDUMP_ENABLE_USER_TRIGGER,): 

608 return self._bool 1f

609 else: 

610 raise TypeError('Unsupported attribute value: {}'.format(self._attrib))