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

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

14cdef void* _callocWrapper(length, size):

15 cdef void* out = calloc(length, size) 13 ctx1qrsfwjakdbecn

16 if out is NULL: 13 ctx1qrsfwjakdbecn

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

18 return out 13 ctx1qrsfwjakdbecn

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 8 ctx1dblomiec

44 self._malloc_list_created = False 8 ctx1dblomiec

45 if kernelParams is None: 8 ctx1dblomiec

46 self._ckernelParams = NULL 1 ctx1i

47 elif isinstance(kernelParams, (int)): 8 ctx1dblomiec

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

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

50 elif PyObject_CheckBuffer(kernelParams): 7 ctx1dblmiec

51 # Easy run, get address from Python Buffer Protocol

52 err_buffer = PyObject_GetBuffer(kernelParams, &self._pybuffer, PyBUF_SIMPLE | PyBUF_ANY_CONTIGUOUS) 2 ctx1lm

53 if err_buffer == -1: 2 ctx1lm

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

55 self._pyobj_acquired = True 2 ctx1lm

56 self._ckernelParams = <void**><void_ptr>self._pybuffer.buf 2 ctx1lm

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

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

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

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

61 if len(kernelParams[0]) != 0: 5 ctx1dbiec

62 self._length = len(kernelParams[0]) 4 ctx1dbec

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

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

65 self._malloc_list_created = True 4 ctx1dbec

67 idx = 0 5 ctx1dbiec

68 data_idx = 0 5 ctx1dbiec

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

70 if ctype is None: 4 ctx1dbec

71 # special cases for None

72 if callable(getattr(value, 'getPtr', None)): 4 ctx1dbec

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

74 elif isinstance(value, (_ctypes.Structure)): 2 ctx1ec

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

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

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

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

79 data_idx += sizeof(int) 1 ctx1c

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: 4 ctx1dbec

83 self._ckernelParams[idx] = &(self._ckernelParamsData[data_idx]) 2 ctx1db

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

86 if ctype == _ctypes.c_double and isinstance(value, _ctypes.c_float): 2 ctx1db

87 value = ctype(value.value) 1 ctx1d

88 if not isinstance(value, ctype): # make it a ctype 2 ctx1db

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

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

91 value = ctype(value) 1 ctx1b

92 size = _ctypes.sizeof(ctype) 1 ctx1b

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

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

95 else:

96 size = _ctypes.sizeof(ctype) 1 ctx1d

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

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

99 data_idx += size 2 ctx1db

100 elif ctype == _ctypes.c_void_p: 4 ctx1dbec

101 # special cases for void_p

102 if isinstance(value, (int, _ctypes.c_void_p)): 4 ctx1dbec

103 self._ckernelParams[idx] = &(self._ckernelParamsData[data_idx]) 4 ctx1dbec

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

105 data_idx += sizeof(void_ptr) 4 ctx1dbec

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

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

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

109 data_idx += sizeof(void_ptr) 1 ctx1c

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 4 ctx1dbec

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: 8 ctx1dblomiec

120 PyBuffer_Release(&self._pybuffer) 2 ctx1lm

121 if self._malloc_list_created is True: 8 ctx1dblomiec

122 free(self._ckernelParams) 4 ctx1dbec

123 free(self._ckernelParamsData) 4 ctx1dbec

124

125 @property

126 def ckernelParams(self):

127 return <void_ptr>self._ckernelParams 8 ctx1dblomiec

128

129cdef class _HelperInputVoidPtr:

130 def __cinit__(self, ptr):

131 self._cptr = _helper_input_void_ptr(ptr, &self._helper) 9 ctx1tuZ0v1234

132

133 def __dealloc__(self):

134 _helper_input_void_ptr_free(&self._helper) 9 ctx1tuZ0v1234

135

136 @property

137 def cptr(self):

138 return <void_ptr>self._cptr 9 ctx1tuZ0v1234

139

140

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

142 helper[0]._pybuffer.buf = NULL 161 ctx25 6 7 8 9 ! # $ % ' ( ) * + , - . / : ; = ? @ [ ] ^ y z A B C D _ ` { | } ~ abbbcbdbt w E u Z 0 F v G H I J K L M N O P Q ebfbgbR hbibjbkblbmbnbobS d b l o m i e c pbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbIbJbKbLbMbNbObPbQbRbSbTbUbVbWbXbYbZb0b1b2b3b4b5b6b7b8b9b!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}b1 2 3 4 n ~b

143 try: 161 ctx25 6 7 8 9 ! # $ % ' ( ) * + , - . / : ; = ? @ [ ] ^ y z A B C D _ ` { | } ~ abbbcbdbt w E u Z 0 F v G H I J K L M N O P Q ebfbgbR hbibjbkblbmbnbobS d b l o m i e c pbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbIbJbKbLbMbNbObPbQbRbSbTbUbVbWbXbYbZb0b1b2b3b4b5b6b7b8b9b!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}b1 2 3 4 n ~b

144 return <void *><void_ptr>ptr 161 ctx25 6 7 8 9 ! # $ % ' ( ) * + , - . / : ; = ? @ [ ] ^ y z A B C D _ ` { | } ~ abbbcbdbt w E u Z 0 F v G H I J K L M N O P Q ebfbgbR hbibjbkblbmbnbobS d b l o m i e c pbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbIbJbKbLbMbNbObPbQbRbSbTbUbVbWbXbYbZb0b1b2b3b4b5b6b7b8b9b!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}b1 2 3 4 n ~b

145 except: 33 ctx1yzABCDtEuFvGHIJKLMNOPQRSdblomiecn

146 if ptr is None: 33 ctx1yzABCDtEuFvGHIJKLMNOPQRSdblomiecn

147 return NULL

148 elif PyObject_CheckBuffer(ptr): 33 ctx1yzABCDtEuFvGHIJKLMNOPQRSdblomiecn

149 # Easy run, get address from Python Buffer Protocol

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

151 if err_buffer == -1: 33 ctx1yzABCDtEuFvGHIJKLMNOPQRSdblomiecn

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

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

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

160cdef class _HelperCUmemPool_attribute:

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

162 self._is_getter = is_getter 2 ctx1gh

163 self._attr = attr.value 2 ctx1gh

164 if self._attr in (cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_FOLLOW_EVENT_DEPENDENCIES, 2 ctx1gh

165 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_ALLOW_OPPORTUNISTIC, 2 ctx1gh

166 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_ALLOW_INTERNAL_DEPENDENCIES,):

167 self._int_val = init_value 2 ctx1gh

168 self._cptr = <void*>&self._int_val 2 ctx1gh

169 elif self._attr in (cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RELEASE_THRESHOLD, 2 ctx1gh

170 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RESERVED_MEM_CURRENT, 2 ctx1gh

171 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RESERVED_MEM_HIGH, 2 ctx1gh

172 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_USED_MEM_CURRENT, 2 ctx1gh

173 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_USED_MEM_HIGH,):

174 if self._is_getter: 2 ctx1gh

175 self._cuuint64_t_val = _driver["cuuint64_t"]() 2 ctx1gh

176 self._cptr = <void*><void_ptr>self._cuuint64_t_val.getPtr() 2 ctx1gh

177 else:

178 self._cptr = <void*><void_ptr>init_value.getPtr() 2 ctx1gh

179 else:

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

181

182 def __dealloc__(self):

183 pass 2 ctx1gh

184

185 @property

186 def cptr(self):

187 return <void_ptr>self._cptr 2 ctx1gh

188

189 def pyObj(self):

190 assert(self._is_getter == True) 2 ctx1gh

191 if self._attr in (cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_FOLLOW_EVENT_DEPENDENCIES, 2 ctx1gh

192 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_ALLOW_OPPORTUNISTIC, 2 ctx1gh

193 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_ALLOW_INTERNAL_DEPENDENCIES,):

194 return self._int_val 2 ctx1gh

195 elif self._attr in (cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RELEASE_THRESHOLD, 2 ctx1gh

196 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RESERVED_MEM_CURRENT, 2 ctx1gh

197 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RESERVED_MEM_HIGH, 2 ctx1gh

198 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_USED_MEM_CURRENT, 2 ctx1gh

199 cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_USED_MEM_HIGH,):

200 return self._cuuint64_t_val 2 ctx1gh

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 11 ctx1TqrsUVWxXYj

209 self._attr = attr.value 11 ctx1TqrsUVWxXYj

210 if self._attr in (cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY, 11 ctx1TqrsUVWxXYj

211 cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION, 2 ctx1xj

212 cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION,):

213 self._cptr = <void*>&self._int_val 8 ctx1TUVWxXYj

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

215 self._cptr = _callocWrapper(1, self._data_size) 4 ctx1qrsj

216 self._int_val_list = <int*>self._cptr 4 ctx1qrsj

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,): 11 ctx1TqrsUVWxXYj

222 free(self._cptr) 4 ctx1qrsj

223

224 @property

225 def cptr(self):

226 return <void_ptr>self._cptr 11 ctx1TqrsUVWxXYj

227

228 def pyObj(self):

229 if self._attr in (cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY, 11 ctx1TqrsUVWxXYj

230 cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION, 2 ctx1xj

231 cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION,):

232 return self._int_val 8 ctx1TUVWxXYj

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))] 4 ctx1qrsj

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 2 ctx1ak

243 self._attr = attr.value 2 ctx1ak

244 if self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_CONTEXT,): 2 ctx1ak

245 if self._is_getter: 1 ctx1a

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

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

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, 1 ctx1a

251 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES, 1 ctx1a

252 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE, 1 ctx1a

253 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_ACCESS_FLAGS,):

254 self._uint = init_value 1 ctx1a

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

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

257 self._int = init_value 2 ctx1ak

258 self._cptr = <void*>&self._int 2 ctx1ak

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

260 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_RANGE_START_ADDR,):

261 if self._is_getter: 1 ctx1a

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

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

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

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

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, 1 ctx1a

276 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_MANAGED, 1 ctx1a

277 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE, 1 ctx1a

278 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MAPPED,):

279 self._bool = init_value 1 ctx1a

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

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

282 self._ull = init_value 1 ctx1a

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

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

285 self._size = init_value 1 ctx1a

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

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

288 if self._is_getter: 1 ctx1a

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

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

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 2 ctx1ak

298

299 @property

300 def cptr(self):

301 return <void_ptr>self._cptr 2 ctx1ak

302

303 def pyObj(self):

304 assert(self._is_getter == True) 2 ctx1ak

305 if self._attr in (cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_CONTEXT,): 2 ctx1ak

306 return self._ctx 1 ctx1a

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

308 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL, 2 ctx1ak

309 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES, 2 ctx1ak

310 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE, 2 ctx1ak

311 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_ACCESS_FLAGS,):

312 return self._uint 2 ctx1ak

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

314 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_RANGE_START_ADDR,):

315 return self._devptr 1 ctx1a

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

317 return <void_ptr>self._void 1 ctx1a

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, 1 ctx1a

321 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_MANAGED, 1 ctx1a

322 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE, 1 ctx1a

323 cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MAPPED,):

324 return self._bool 1 ctx1a

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

326 return self._ull 1 ctx1a

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

328 return self._size 1 ctx1a

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

330 return self._mempool 1 ctx1a

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

339 self._attr = attr.value 1 ctx1p

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

341 cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_USED_MEM_HIGH, 1 ctx1p

342 cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT, 1 ctx1p

343 cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH,):

344 if self._is_getter: 1 ctx1p

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

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

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

354

355 @property

356 def cptr(self):

357 return <void_ptr>self._cptr 1 ctx1p

358

359 def pyObj(self):

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

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

362 cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_USED_MEM_HIGH, 1 ctx1p

363 cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT, 1 ctx1p

364 cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH,):

365 return self._cuuint64_t_val 1 ctx1p

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

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

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

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

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 5 ctx1wjakn

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

644 for idx in range(len(lst)): 5 ctx1wjakn

645 self._cptr[idx] = <void*><void_ptr>lst[idx].cptr 3 ctx1jak

646

647 def __dealloc__(self):

648 free(self._cptr) 5 ctx1wjakn

649

650 @property

651 def cptr(self):

652 return <void_ptr>self._cptr 5 ctx1wjakn

653

654

655

656cdef class _HelperCUcoredumpSettings:

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

658 self._is_getter = is_getter 1 ctx1f

659 self._attrib = attr.value 1 ctx1f

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

661 cydriver.CUcoredumpSettings_enum.CU_COREDUMP_PIPE,):

662 if self._is_getter: 1 ctx1f

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

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

665 self._size = 1024 1 ctx1f

666 else:

667 self._charstar = init_value 1 ctx1f

668 self._cptr = <void*><void_ptr>self._charstar 1 ctx1f

669 self._size = len(init_value) 1 ctx1f

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

671 cydriver.CUcoredumpSettings_enum.CU_COREDUMP_TRIGGER_HOST, 1 ctx1f

672 cydriver.CUcoredumpSettings_enum.CU_COREDUMP_LIGHTWEIGHT, 1 ctx1f

673 cydriver.CUcoredumpSettings_enum.CU_COREDUMP_ENABLE_USER_TRIGGER,):

674 if self._is_getter == False: 1 ctx1f

675 self._bool = init_value 1 ctx1f

676

677 self._cptr = <void*>&self._bool 1 ctx1f

678 self._size = 1 1 ctx1f

679 else:

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

681

682 def __dealloc__(self):

683 pass 1 ctx1f

684

685 @property

686 def cptr(self):

687 return <void_ptr>self._cptr 1 ctx1f

688

689 def size(self):

690 return self._size 1 ctx1f

691

692 def pyObj(self):

693 assert(self._is_getter == True) 1 ctx1f

694 if self._attrib in (cydriver.CUcoredumpSettings_enum.CU_COREDUMP_FILE, 1 ctx1f

695 cydriver.CUcoredumpSettings_enum.CU_COREDUMP_PIPE,):

696 return self._charstar 1 ctx1f

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

698 cydriver.CUcoredumpSettings_enum.CU_COREDUMP_TRIGGER_HOST, 1 ctx1f

699 cydriver.CUcoredumpSettings_enum.CU_COREDUMP_LIGHTWEIGHT, 1 ctx1f

700 cydriver.CUcoredumpSettings_enum.CU_COREDUMP_ENABLE_USER_TRIGGER,):

701 return self._bool 1 ctx1f

702 else:

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