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

391 statements  

« prev     ^ index     » next       coverage.py v7.15.2, created at 2026-07-29 01:38 +0000

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

2# SPDX-License-Identifier: Apache-2.0 

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) 1fbhdzABCkIpaqgcjiev

16 if out is NULL: 1fbhdzABCkIpaqgcjiev

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

18 return out 1fbhdzABCkIpaqgcjiev

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

44 self._malloc_list_created = False 1fbrwsnhdgctxujoie

45 if kernelParams is None: 1fbrwsnhdgctxujoie

46 self._ckernelParams = NULL 1no

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

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

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

50 elif PyObject_CheckBuffer(kernelParams): 1fbrsnhdgctujoie

51 # Easy run, get address from Python Buffer Protocol 

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

53 if err_buffer == -1: 1rstu

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

55 self._pyobj_acquired = True 1rstu

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

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

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

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

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

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

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

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

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

65 self._malloc_list_created = True 1fbhdgcjie

66  

67 idx = 0 1fbnhdgcjoie

68 data_idx = 0 1fbnhdgcjoie

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

70 if ctype is None: 1fbhdgcjie

71 # special cases for None 

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

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

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

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

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

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

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

79 data_idx += sizeof(int) 1de

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

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

84  

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

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

87 value = ctype(value.value) 1fg

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

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

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

91 value = ctype(value) 1bc

92 size = _ctypes.sizeof(ctype) 1bc

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

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

95 else: 

96 size = _ctypes.sizeof(ctype) 1fg

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

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

99 data_idx += size 1fbgcj

100 elif ctype == _ctypes.c_void_p: 1fbhdgcie

101 # special cases for void_p 

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

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

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

105 data_idx += sizeof(void_ptr) 1fbhdgcie

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

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

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

109 data_idx += sizeof(void_ptr) 1de

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

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

120 PyBuffer_Release(&self._pybuffer) 1rstu

121 if self._malloc_list_created is True: 1fbrwsnhdgctxujoie

122 free(self._ckernelParams) 1fbhdgcjie

123 free(self._ckernelParamsData) 1fbhdgcjie

124  

125 @property 

126 def ckernelParams(self): 

127 return <void_ptr>self._ckernelParams 1fbrwsnhdgctxujoie

128  

129cdef class _HelperInputVoidPtr: 

130 def __cinit__(self, ptr): 

131 self._cptr = _helper_input_void_ptr(ptr, &self._helper) 1FG]^H_`{|

132  

133 def __dealloc__(self): 

134 _helper_input_void_ptr_free(&self._helper) 1FG]^H_`{|

135  

136 @property 

137 def cptr(self): 

138 return <void_ptr>self._cptr 1FG]^H_`{|

139  

140  

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

142 helper[0]._pybuffer.buf = NULL 2} ~ abbbcbdbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbK L M N O P Q R S T U V W X DbEbFbGbHbIbJbKbLbMbNbf b r w s n h d ObF I Y G ] ^ Z H 0 1 2 3 4 5 6 7 8 9 ! PbQbRb# $ % Sb' ( Tb) * + , - . UbVbWbXbYbZb/ g c t x u j o i e 0b1b2b3b4b5b6b7b8b9b!b#b$b%b'b(b)b*b+b,b-b.b/b:b;b=b?b@b[b]b^b_b`b{b|b}b~bacbcccdcecfcgchcicjckclcmcncocpcqcrcsctcucvcwcxcyczcAcBcCcDcEcFcGcHcIc_ ` { | v JcKcLc

143 try: 2} ~ abbbcbdbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbK L M N O P Q R S T U V W X DbEbFbGbHbIbJbKbLbMbNbf b r w s n h d ObF I Y G ] ^ Z H 0 1 2 3 4 5 6 7 8 9 ! PbQbRb# $ % Sb' ( Tb) * + , - . UbVbWbXbYbZb/ g c t x u j o i e 0b1b2b3b4b5b6b7b8b9b!b#b$b%b'b(b)b*b+b,b-b.b/b:b;b=b?b@b[b]b^b_b`b{b|b}b~bacbcccdcecfcgchcicjckclcmcncocpcqcrcsctcucvcwcxcyczcAcBcCcDcEcFcGcHcIc_ ` { | v JcKcLc

144 return <void *><void_ptr>ptr 2} ~ abbbcbdbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbK L M N O P Q R S T U V W X DbEbFbGbHbIbJbKbLbMbNbf b r w s n h d ObF I Y G ] ^ Z H 0 1 2 3 4 5 6 7 8 9 ! PbQbRb# $ % Sb' ( Tb) * + , - . UbVbWbXbYbZb/ g c t x u j o i e 0b1b2b3b4b5b6b7b8b9b!b#b$b%b'b(b)b*b+b,b-b.b/b:b;b=b?b@b[b]b^b_b`b{b|b}b~bacbcccdcecfcgchcicjckclcmcncocpcqcrcsctcucvcwcxcyczcAcBcCcDcEcFcGcHcIc_ ` { | v JcKcLc

145 except: 1KLMNOPQRSTUVWXfbrwsnhdFYGZH0123456789!#$%'()*+,-./gctxujoiev

146 if ptr is None: 1KLMNOPQRSTUVWXfbrwsnhdFYGZH0123456789!#$%'()*+,-./gctxujoiev

147 return NULL 

148 elif PyObject_CheckBuffer(ptr): 1KLMNOPQRSTUVWXfbrwsnhdFYGZH0123456789!#$%'()*+,-./gctxujoiev

149 # Easy run, get address from Python Buffer Protocol 

150 err_buffer = PyObject_GetBuffer(ptr, &helper[0]._pybuffer, PyBUF_SIMPLE | PyBUF_ANY_CONTIGUOUS) 1KLMNOPQRSTUVWXfbrwsnhdFYGZH0123456789!#$%'()*+,-./gctxujoiev

151 if err_buffer == -1: 1KLMNOPQRSTUVWXfbrwsnhdFYGZH0123456789!#$%'()*+,-./gctxujoiev

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

153 return <void*><void_ptr>(helper[0]._pybuffer.buf) 1KLMNOPQRSTUVWXfbrwsnhdFYGZH0123456789!#$%'()*+,-./gctxujoiev

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  

158  

159  

160cdef class _HelperCUmemPool_attribute: 

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

162 self._is_getter = is_getter 1lm

163 self._attr = attr.value 1lm

164 if self._attr in (cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_FOLLOW_EVENT_DEPENDENCIES, 1lm

165 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_ALLOW_OPPORTUNISTIC, 1lm

166 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_ALLOW_INTERNAL_DEPENDENCIES,): 

167 self._int_val = init_value 1lm

168 self._cptr = <void*>&self._int_val 1lm

169 elif self._attr in (cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RELEASE_THRESHOLD, 1lm

170 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RESERVED_MEM_CURRENT, 1lm

171 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RESERVED_MEM_HIGH, 1lm

172 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_USED_MEM_CURRENT, 1lm

173 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_USED_MEM_HIGH,): 

174 if self._is_getter: 1lm

175 self._cuuint64_t_val = _driver["cuuint64_t"]() 1lm

176 self._cptr = <void*><void_ptr>self._cuuint64_t_val.getPtr() 1lm

177 else: 

178 self._cptr = <void*><void_ptr>init_value.getPtr() 1lm

179 else: 

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

181  

182 def __dealloc__(self): 

183 pass 1lm

184  

185 @property 

186 def cptr(self): 

187 return <void_ptr>self._cptr 1lm

188  

189 def pyObj(self): 

190 assert(self._is_getter == True) 1lm

191 if self._attr in (cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_FOLLOW_EVENT_DEPENDENCIES, 1lm

192 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_ALLOW_OPPORTUNISTIC, 1lm

193 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_ALLOW_INTERNAL_DEPENDENCIES,): 

194 return self._int_val 1lm

195 elif self._attr in (cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RELEASE_THRESHOLD, 1lm

196 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RESERVED_MEM_CURRENT, 1lm

197 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RESERVED_MEM_HIGH, 1lm

198 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_USED_MEM_CURRENT, 1lm

199 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_USED_MEM_HIGH,): 

200 return self._cuuint64_t_val 1lm

201 else: 

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

203  

204  

205  

206cdef class _HelperCUmem_range_attribute: 

207 def __cinit__(self, attr, data_size): 

208 self._data_size = data_size 1:zABC;=?J@[p

209 self._attr = attr.value 1:zABC;=?J@[p

210 if self._attr in (cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY, 1:zABC;=?J@[p

211 cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION, 1Jp

212 cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION,): 

213 self._cptr = <void*>&self._int_val 1:;=?J@[p

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

215 self._cptr = _callocWrapper(1, self._data_size) 1zABCp

216 self._int_val_list = <int*>self._cptr 1zABCp

217 else: 

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

219  

220 def __dealloc__(self): 

221 if self._attr in (cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY,): 1:zABC;=?J@[p

222 free(self._cptr) 1zABCp

223  

224 @property 

225 def cptr(self): 

226 return <void_ptr>self._cptr 1:zABC;=?J@[p

227  

228 def pyObj(self): 

229 if self._attr in (cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY, 1:zABC;=?J@[p

230 cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION, 1Jp

231 cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION,): 

232 return self._int_val 1:;=?J@[p

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

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

235 else: 

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

237  

238  

239  

240cdef class _HelperCUpointer_attribute: 

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

242 self._is_getter = is_getter 1aqDE

243 self._attr = attr.value 1aqDE

244 if self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_CONTEXT,): 1aqDE

245 if self._is_getter: 1a

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

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

248 else: 

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

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

251 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES, 1a

252 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE, 1a

253 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_ACCESS_FLAGS,): 

254 self._uint = init_value 1a

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

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

257 self._int = init_value 1aqDE

258 self._cptr = <void*>&self._int 1aqDE

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

260 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_RANGE_START_ADDR,): 

261 if self._is_getter: 1a

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

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

264 else: 

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

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

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

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

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

270 if self._is_getter: 

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

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

273 else: 

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

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

276 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_MANAGED, 1a

277 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE, 1a

278 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MAPPED,): 

279 self._bool = init_value 1a

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

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

282 self._ull = init_value 1a

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

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

285 self._size = init_value 1a

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

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

288 if self._is_getter: 1a

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

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

291 else: 

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

293 else: 

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

295  

296 def __dealloc__(self): 

297 pass 1aqDE

298  

299 @property 

300 def cptr(self): 

301 return <void_ptr>self._cptr 1aqDE

302  

303 def pyObj(self): 

304 assert(self._is_getter == True) 1aqDE

305 if self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_CONTEXT,): 1aqDE

306 return self._ctx 1a

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

308 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL, 1aqDE

309 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES, 1aqDE

310 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE, 1aqDE

311 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_ACCESS_FLAGS,): 

312 return self._uint 1aqDE

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

314 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_RANGE_START_ADDR,): 

315 return self._devptr 1a

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

317 return <void_ptr>self._void 1a

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

319 return self._token 

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

321 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_MANAGED, 1a

322 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE, 1a

323 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MAPPED,): 

324 return self._bool 1a

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

326 return self._ull 1a

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

328 return self._size 1a

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

330 return self._mempool 1a

331 else: 

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

333  

334  

335  

336cdef class _HelperCUgraphMem_attribute: 

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

338 self._is_getter = is_getter 1y

339 self._attr = attr.value 1y

340 if self._attr in (cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_USED_MEM_CURRENT, 1y

341 cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_USED_MEM_HIGH, 1y

342 cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT, 1y

343 cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH,): 

344 if self._is_getter: 1y

345 self._cuuint64_t_val = _driver["cuuint64_t"]() 1y

346 self._cptr = <void*><void_ptr>self._cuuint64_t_val.getPtr() 1y

347 else: 

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

349 else: 

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

351  

352 def __dealloc__(self): 

353 pass 1y

354  

355 @property 

356 def cptr(self): 

357 return <void_ptr>self._cptr 1y

358  

359 def pyObj(self): 

360 assert(self._is_getter == True) 1y

361 if self._attr in (cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_USED_MEM_CURRENT, 1y

362 cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_USED_MEM_HIGH, 1y

363 cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT, 1y

364 cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH,): 

365 return self._cuuint64_t_val 1y

366 else: 

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

368  

369  

370  

371cdef class _HelperCUjit_option: 

372 def __cinit__(self, attr, init_value): 

373 self._attr = attr.value 

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

375 cydriver.CUjit_option_enum.CU_JIT_THREADS_PER_BLOCK, 

376 cydriver.CUjit_option_enum.CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES, 

377 cydriver.CUjit_option_enum.CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES, 

378 cydriver.CUjit_option_enum.CU_JIT_OPTIMIZATION_LEVEL, 

379 cydriver.CUjit_option_enum.CU_JIT_GLOBAL_SYMBOL_COUNT, 

380 cydriver.CUjit_option_enum.CU_JIT_TARGET_FROM_CUCONTEXT, 

381 cydriver.CUjit_option_enum.CU_JIT_REFERENCED_KERNEL_COUNT, 

382 cydriver.CUjit_option_enum.CU_JIT_REFERENCED_VARIABLE_COUNT, 

383 cydriver.CUjit_option_enum.CU_JIT_MIN_CTA_PER_SM, 

384 cydriver.CUjit_option_enum.CU_JIT_SPLIT_COMPILE,): 

385 self._uint = init_value 

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

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

388 self._float = init_value 

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

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

391 cydriver.CUjit_option_enum.CU_JIT_ERROR_LOG_BUFFER): 

392 self._charstar = init_value 

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

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

395 self._target = init_value.value 

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

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

398 self._fallback = init_value.value 

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

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

401 cydriver.CUjit_option_enum.CU_JIT_LOG_VERBOSE, 

402 cydriver.CUjit_option_enum.CU_JIT_GENERATE_LINE_INFO, 

403 cydriver.CUjit_option_enum.CU_JIT_LTO, 

404 cydriver.CUjit_option_enum.CU_JIT_FTZ, 

405 cydriver.CUjit_option_enum.CU_JIT_PREC_DIV, 

406 cydriver.CUjit_option_enum.CU_JIT_PREC_SQRT, 

407 cydriver.CUjit_option_enum.CU_JIT_FMA, 

408 cydriver.CUjit_option_enum.CU_JIT_OPTIMIZE_UNUSED_DEVICE_VARIABLES,): 

409 self._int = init_value 

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

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

412 self._cacheMode = init_value.value 

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

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

415 cydriver.CUjit_option_enum.CU_JIT_REFERENCED_KERNEL_NAMES, 

416 cydriver.CUjit_option_enum.CU_JIT_REFERENCED_VARIABLE_NAMES,): 

417 self._charstarstar = init_value 

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

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

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

421 self._voidstarstar = _InputVoidPtrPtrHelper(pylist) 

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

423 else: 

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

425  

426 def __dealloc__(self): 

427 pass 

428  

429 @property 

430 def cptr(self): 

431 return <void_ptr>self._cptr 

432  

433  

434  

435  

436cdef class _HelperCudaJitOption: 

437 def __cinit__(self, attr, init_value): 

438 self._attr = attr.value 

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

440 cyruntime.cudaJitOption.cudaJitThreadsPerBlock, 

441 cyruntime.cudaJitOption.cudaJitInfoLogBufferSizeBytes, 

442 cyruntime.cudaJitOption.cudaJitErrorLogBufferSizeBytes, 

443 cyruntime.cudaJitOption.cudaJitOptimizationLevel, 

444 cyruntime.cudaJitOption.cudaJitMinCtaPerSm,): 

445 self._uint = init_value 

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

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

448 self._float = init_value 

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

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

451 cyruntime.cudaJitOption.cudaJitErrorLogBuffer): 

452 self._charstar = init_value 

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

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

455 self._fallback = init_value.value 

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

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

458 cyruntime.cudaJitOption.cudaJitLogVerbose, 

459 cyruntime.cudaJitOption.cudaJitGenerateLineInfo, 

460 cyruntime.cudaJitOption.cudaJitPositionIndependentCode, 

461 cyruntime.cudaJitOption.cudaJitMaxThreadsPerBlock, 

462 cyruntime.cudaJitOption.cudaJitOverrideDirectiveValues,): 

463 self._int = init_value 

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

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

466 self._cacheMode = init_value.value 

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

468 else: 

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

470  

471 def __dealloc__(self): 

472 pass 

473  

474 @property 

475 def cptr(self): 

476 return <void_ptr>self._cptr 

477  

478  

479  

480  

481cdef class _HelperCUlibraryOption: 

482 def __cinit__(self, attr, init_value): 

483 self._attr = attr.value 

484 if False: 

485 pass 

486  

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

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

489  

490  

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

492 self._uint = init_value 

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

494  

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  

505  

506  

507  

508cdef class _HelperCudaLibraryOption: 

509 def __cinit__(self, attr, init_value): 

510 self._attr = attr.value 

511 if False: 

512 pass 

513  

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

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

516  

517  

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

519 self._uint = init_value 

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

521  

522 else: 

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

524  

525 def __dealloc__(self): 

526 pass 

527  

528 @property 

529 def cptr(self): 

530 return <void_ptr>self._cptr 

531  

532  

533  

534  

535cdef class _HelperCUmemAllocationHandleType: 

536 def __cinit__(self, attr): 

537 self._type = attr.value 

538 if False: 

539 pass 

540  

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

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

543  

544  

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

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

547  

548  

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

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

551  

552  

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

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

555  

556  

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

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

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

560  

561 else: 

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

563  

564 def __dealloc__(self): 

565 pass 

566  

567 @property 

568 def cptr(self): 

569 return <void_ptr>self._cptr 

570  

571 def pyObj(self): 

572 if False: 

573 pass 

574  

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

576 return self._int 

577  

578  

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

580 return self._int 

581  

582  

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

584 return <void_ptr>self._handle 

585  

586  

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

588 return self._d3dkmt_handle 

589  

590  

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

592 return self._mem_fabric_handle 

593  

594 else: 

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

596  

597  

598  

599cdef class _HelperCUlogicalEndpointIpcHandleType: 

600 def __cinit__(self, attr): 

601 self._type = attr.value 

602 if False: 

603 pass 

604  

605 elif self._type in (cydriver.CUlogicalEndpointIpcHandleType_enum.CU_LOGICAL_ENDPOINT_IPC_HANDLE_TYPE_NONE,): 

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

607  

608  

609 elif self._type in (cydriver.CUlogicalEndpointIpcHandleType_enum.CU_LOGICAL_ENDPOINT_IPC_HANDLE_TYPE_FABRIC,): 

610 self._fabric_handle = _driver["CUlogicalEndpointFabricHandle"]() 

611 self._cptr = <void*><void_ptr>self._fabric_handle.getPtr() 

612  

613 else: 

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

615  

616 def __dealloc__(self): 

617 pass 

618  

619 @property 

620 def cptr(self): 

621 return <void_ptr>self._cptr 

622  

623 def pyObj(self): 

624 if False: 

625 pass 

626  

627 elif self._type in (cydriver.CUlogicalEndpointIpcHandleType_enum.CU_LOGICAL_ENDPOINT_IPC_HANDLE_TYPE_NONE,): 

628 return self._int 

629  

630  

631 elif self._type in (cydriver.CUlogicalEndpointIpcHandleType_enum.CU_LOGICAL_ENDPOINT_IPC_HANDLE_TYPE_FABRIC,): 

632 return self._fabric_handle 

633  

634 else: 

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

636  

637  

638cdef class _InputVoidPtrPtrHelper: 

639 def __cinit__(self, lst): 

640 # Hold onto references to the original buffers so they 

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

642 self._references = lst 1Ipaqv

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

644 for idx in range(len(lst)): 1Ipaqv

645 self._cptr[idx] = <void*><void_ptr>lst[idx].cptr 1paq

646  

647 def __dealloc__(self): 

648 free(self._cptr) 1Ipaqv

649  

650 @property 

651 def cptr(self): 

652 return <void_ptr>self._cptr 1Ipaqv

653  

654  

655  

656cdef class _HelperCUcoredumpSettings: 

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

658 self._is_getter = is_getter 1k

659 self._attrib = attr.value 1k

660 if self._attrib in (cydriver.CUcoredumpSettings_enum.CU_COREDUMP_FILE, 1k

661 cydriver.CUcoredumpSettings_enum.CU_COREDUMP_PIPE,): 

662 if self._is_getter: 1k

663 self._charstar = <char*>_callocWrapper(1024, 1) 1k

664 self._cptr = <void*><void_ptr>self._charstar 1k

665 self._size = 1024 1k

666 else: 

667 # Keep a reference so the borrowed _charstar buffer stays alive. 

668 self._references = init_value 1k

669 self._charstar = init_value 1k

670 self._cptr = <void*><void_ptr>self._charstar 1k

671 self._size = len(init_value) 1k

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

673 cydriver.CUcoredumpSettings_enum.CU_COREDUMP_TRIGGER_HOST, 1k

674 cydriver.CUcoredumpSettings_enum.CU_COREDUMP_LIGHTWEIGHT, 1k

675 cydriver.CUcoredumpSettings_enum.CU_COREDUMP_ENABLE_USER_TRIGGER,): 

676 if self._is_getter == False: 1k

677 self._bool = init_value 1k

678  

679 self._cptr = <void*>&self._bool 1k

680 self._size = 1 1k

681 else: 

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

683  

684 def __dealloc__(self): 

685 # Only the getter path owns heap (the calloc'd 1024-byte buffer). The 

686 # setter borrows caller bytes and the bool path points at &self._bool, 

687 # so only free for the getter. 

688 if self._is_getter: 1k

689 free(self._charstar) 1k

690  

691 @property 

692 def cptr(self): 

693 return <void_ptr>self._cptr 1k

694  

695 def size(self): 

696 return self._size 1k

697  

698 def pyObj(self): 

699 assert(self._is_getter == True) 1k

700 if self._attrib in (cydriver.CUcoredumpSettings_enum.CU_COREDUMP_FILE, 1k

701 cydriver.CUcoredumpSettings_enum.CU_COREDUMP_PIPE,): 

702 return self._charstar 1k

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

704 cydriver.CUcoredumpSettings_enum.CU_COREDUMP_TRIGGER_HOST, 1k

705 cydriver.CUcoredumpSettings_enum.CU_COREDUMP_LIGHTWEIGHT, 1k

706 cydriver.CUcoredumpSettings_enum.CU_COREDUMP_ENABLE_USER_TRIGGER,): 

707 return self._bool 1k

708 else: 

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