Coverage for cuda/core/_memoryview.pyx: 84.93%

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

2# 

3# SPDX-License-Identifier: Apache-2.0 

4  

5from __future__ import annotations 

6  

7cimport cython 

8from ._dlpack cimport * 

9from ._dlpack import classify_dl_device (empty)

10from libc.stdint cimport intptr_t 

11from cuda.core._layout cimport _StridedLayout, get_strides_ptr 

12from cuda.core._stream import Stream (empty)

13  

14import ctypes (empty)

15import functools (empty)

16import sys (empty)

17import warnings (empty)

18from collections.abc import Callable # no-cython-lint # used in string annotations below (empty)

19from typing import Any # no-cython-lint # used in string annotations below (empty)

20  

21import numpy (empty)

22  

23from cuda.bindings cimport cydriver 

24from cuda.core._resource_handles cimport ( 

25 EventHandle, 

26 create_event_handle_noctx, 

27 as_cu, 

28) 

29  

30from cuda.core._utils.cuda_utils import handle_return, driver (empty)

31from cuda.core._utils.cuda_utils cimport HANDLE_RETURN 

32  

33  

34from cuda.core._memory import Buffer (empty)

35  

36  

37# --------------------------------------------------------------------------- 

38# Lazy tensor bridge (avoids loading _tensor_bridge.so until torch is used) 

39# --------------------------------------------------------------------------- 

40  

41cdef object _tensor_bridge = None (empty)

42# Cache: type(obj) -> True/False for the torch tensor check. 

43# Once a type is seen, we never re-check. 

44cdef dict _torch_type_cache = {} (empty)

45# Tri-state: None = not checked, True/False = result of version check 

46cdef object _torch_version_ok = None (empty)

47  

48cdef inline bint _torch_version_check(): (empty)

49 """Return True if 2.3 <= torch <= 2.12 (known AOTI ABI range). Memoized. 

50  

51 Lower bound: AOTI functions we use were introduced in PyTorch 2.3. 

52 Upper bound: the ``pyobj_to_aten_handle`` trick relies on the 

53 THPVariable struct layout (PyObject_HEAD followed by at::Tensor cdata) 

54 and the identity ``AtenTensorHandle == at::Tensor*``. Both are 

55 undocumented internals that could change in a future PyTorch version. 

56 We cap at the latest version we have tested against; unknown versions 

57 fall back to the standard DLPack/CAI paths. Bump the upper bound 

58 after verifying a new PyTorch release. 

59 """ 

60 global _torch_version_ok 

61 if _torch_version_ok is not None: 

62 return <bint>_torch_version_ok 

63 torch = sys.modules.get("torch") 

64 if torch is None: 

65 _torch_version_ok = False 

66 return False 

67 try: 

68 major, minor = int(torch.__version__.split(".")[0]), \ 

69 int(torch.__version__.split(".")[1]) 

70 _torch_version_ok = (2, 3) <= (major, minor) <= (2, 12) 

71 except (ValueError, IndexError): 

72 _torch_version_ok = False 

73 return <bint>_torch_version_ok 

74  

75  

76cdef inline bint _is_torch_tensor(object obj): (empty)

77 cdef type tp = type(obj) 84 ctx21 2 3 8 V P J K L M N Q R S T U v x y w ! # - $ . % ' ( ) * / : ; = ? @ [ ] ^ + _ ` { , Kb| Ib} 6 7 g I 5 H 4 B C D E F G A b s d e h i j o p q r k l m n f u t c Lba Mb

78 cdef object cached = _torch_type_cache.get(tp) 84 ctx21 2 3 8 V P J K L M N Q R S T U v x y w ! # - $ . % ' ( ) * / : ; = ? @ [ ] ^ + _ ` { , Kb| Ib} 6 7 g I 5 H 4 B C D E F G A b s d e h i j o p q r k l m n f u t c Lba Mb

79 if cached is not None: 84 ctx21 2 3 8 V P J K L M N Q R S T U v x y w ! # - $ . % ' ( ) * / : ; = ? @ [ ] ^ + _ ` { , Kb| Ib} 6 7 g I 5 H 4 B C D E F G A b s d e h i j o p q r k l m n f u t c Lba Mb

80 return <bint>cached 75 ctx23 8 V J K L M N Q R S T U x y w ! # - $ . % ' ( ) * / : ; = ? @ [ ] ^ + _ ` { , Kb6 7 g I 5 H B C D E F G A b s d e h i j o p q r k l m n f u t c Lba

81 cdef str mod = tp.__module__ or "" 10 ctx21 2 P v | Ib} 4 a Mb

82 cdef bint result = mod.startswith("torch") and hasattr(obj, "data_ptr") \ 10 ctx21 2 P v | Ib} 4 a Mb

83 and _torch_version_check() 

84 _torch_type_cache[tp] = result # setdefault not needed for bools 10 ctx21 2 P v | Ib} 4 a Mb

85 return result 10 ctx21 2 P v | Ib} 4 a Mb

86  

87  

88cdef object _get_tensor_bridge(): (empty)

89 """Bootstrap AOTI symbols, then import _tensor_bridge on first use.""" 

90 global _tensor_bridge 

91 if _tensor_bridge is not None: 

92 return _tensor_bridge 

93 torch_C = sys.modules.get("torch._C") 

94 if torch_C is None: 

95 raise RuntimeError( 

96 "torch._C is not loaded; cannot initialise the tensor bridge. " 

97 "Make sure PyTorch is imported before passing a torch.Tensor.") 

98 ctypes.CDLL(torch_C.__file__, mode=ctypes.RTLD_GLOBAL) 

99 from cuda.core import _tensor_bridge as tb 

100 _tensor_bridge = tb 

101 return _tensor_bridge 

102  

103  

104try: (empty)

105 from ml_dtypes import bfloat16 (empty)

106except ImportError: (empty)

107 bfloat16 = None (empty)

108  

109# TODO(leofang): support NumPy structured dtypes 

110  

111  

112cdef extern from "Python.h": 

113 ctypedef struct PyTypeObject: 

114 void* tp_dict 

115 void PyType_Modified(PyTypeObject*) 

116  

117  

118cdef DLPackExchangeAPI _SMV_DLPACK_EXCHANGE_API 

119cdef bint _SMV_DLPACK_EXCHANGE_API_INITED = False (empty)

120_SMV_DLPACK_EXCHANGE_API_CAPSULE = cpython.PyCapsule_New( (empty)

121 <void*>&_SMV_DLPACK_EXCHANGE_API, 

122 b"dlpack_exchange_api", 

123 NULL, 

124) 

125  

126  

127cdef class StridedMemoryView: 

128 """A class holding metadata of a strided dense array/tensor. 

129  

130 A :obj:`StridedMemoryView` instance can be created in three ways: 

131  

132 1. Using the :obj:`args_viewable_as_strided_memory` decorator (recommended) 

133 2. Explicit construction relying on DLPack or CUDA Array Interface, see below. 

134 3. From :obj:`~_memory.Buffer` and shape and size tuples (see 

135 :meth:`from_buffer` classmethod) 

136  

137 ``StridedMemoryView(obj, stream_ptr)`` can be used to create a view from 

138 objects supporting either DLPack (up to v1.0) or CUDA Array Interface 

139 (CAI) v3. When wrapping an arbitrary object it will try the DLPack protocol 

140 first, then the CAI protocol. A :obj:`BufferError` is raised if neither is 

141 supported. 

142  

143 Since either way would take a consumer stream, for DLPack it is passed to 

144 ``obj.__dlpack__()`` as-is (except for :obj:`None`, see below); for CAI, a 

145 stream order will be established between the consumer stream and the 

146 producer stream (from ``obj.__cuda_array_interface__()["stream"]``), as if 

147 ``cudaStreamWaitEvent`` is called by this method. 

148  

149 To opt-out of the stream ordering operation in either DLPack or CAI, 

150 please pass ``stream_ptr=-1``. Note that this deviates (on purpose) 

151 from the semantics of ``obj.__dlpack__(stream=None, ...)`` since ``cuda.core`` 

152 does not encourage using the (legacy) default/null stream, but is 

153 consistent with the CAI's semantics. For DLPack, ``stream=-1`` will be 

154 internally passed to ``obj.__dlpack__()`` instead. 

155  

156 Parameters 

157 ---------- 

158 obj : Any 

159 Any objects that supports either DLPack (up to v1.0) or CUDA Array 

160 Interface (v3). 

161 stream_ptr: int 

162 The pointer address (as Python `int`) to the **consumer** stream. 

163 Stream ordering will be properly established unless ``-1`` is passed. 

164  

165  

166 Attributes 

167 ----------- 

168 ptr : int 

169 Pointer to the tensor buffer (as a Python `int`). 

170 device_id : int 

171 The device ID for where the tensor is located. It is -1 for CPU tensors 

172 (meaning those only accessible from the host). 

173 is_device_accessible : bool 

174 Whether the tensor data can be accessed on the GPU. 

175 readonly: bool 

176 Whether the tensor data can be modified in place. 

177 exporting_obj : Any 

178 A reference to the original tensor object that is being viewed. 

179 If the view is created with :meth:`from_buffer`, 

180 it will be the Buffer instance passed to the method. 

181  

182 """ 

183 def __init__(self, obj: object = None, stream_ptr: int | None = None) -> None: 

184 cdef str clsname = self.__class__.__name__ 7 ctx2W X Y Z 0 Ob~

185 if obj is not None: 8 ctx2z W X Y Z 0 Ob~

186 # populate self's attributes 

187 if check_has_dlpack(obj): 6 ctx1WXYZ0~

188 warnings.warn( 5 ctx1WXYZ0

189 f"Constructing a {clsname} directly from a DLPack-supporting object is deprecated; " 5 ctx1WXYZ0

190 "Use `StridedMemoryView.from_dlpack` or `StridedMemoryView.from_any_interface` instead.", 

191 DeprecationWarning, 5 ctx1WXYZ0

192 stacklevel=2, 

193 ) 

194 view_as_dlpack(obj, stream_ptr, self) 6 ctx1zWXYZ0

195 else: 

196 warnings.warn( 1 ctx1~

197 f"Constructing a {clsname} directly from a CUDA-array-interface-supporting object is deprecated; " 1 ctx1~

198 "Use `StridedMemoryView.from_cuda_array_interface` or `StridedMemoryView.from_any_interface` instead.", 

199 DeprecationWarning, 1 ctx1~

200 stacklevel=2, 

201 ) 

202 view_as_cai(obj, stream_ptr, self) 1 ctx1~

203 else: 

204 warnings.warn( 1 ctx2Ob

205 f"Constructing an empty {clsname} is deprecated; " 1 ctx2Ob

206 "use one of the classmethods `from_dlpack`, `from_cuda_array_interface` or `from_any_interface` " 

207 "to construct a StridedMemoryView from an object", 

208 DeprecationWarning, 1 ctx2Ob

209 stacklevel=2, 

210 ) 

211  

212 @classmethod (empty)

213 def from_dlpack(cls, obj: object, stream_ptr: int | None=None) -> StridedMemoryView: 

214 """Create a view from an object supporting the `DLPack <https://dmlc.github.io/dlpack/latest/>`_ protocol. 

215  

216 Parameters 

217 ---------- 

218 obj : object 

219 An object implementing the `DLPack <https://dmlc.github.io/dlpack/latest/>`_ protocol 

220 (via ``__dlpack__``). 

221 stream_ptr : int, optional 

222 Stream pointer for synchronization. If ``None``, no synchronization is performed. 

223 """ 

224 cdef StridedMemoryView buf = StridedMemoryView.__new__(cls) 54 ctx21 2 3 8 V P J K L M N Q R S T U x y w 6 7 g I 5 H B C D E F G A b s d e h i j o p q r k l m n f u t c Lba Mb

225 if _is_torch_tensor(obj): 54 ctx21 2 3 8 V P J K L M N Q R S T U x y w 6 7 g I 5 H B C D E F G A b s d e h i j o p q r k l m n f u t c Lba Mb

226 _get_tensor_bridge().view_as_torch_tensor(obj, stream_ptr, buf) 

227 return buf 

228 view_as_dlpack(obj, stream_ptr, buf) 54 ctx21 2 3 8 V P J K L M N Q R S T U x y w 6 7 g I 5 H B C D E F G A b s d e h i j o p q r k l m n f u t c Lba Mb

229 return buf 52 ctx11238VPJKLMNQRSTUxyw67gI5HBCDEFGAbsdehijopqrklmnfutca

230  

231 @classmethod (empty)

232 def from_cuda_array_interface(cls, obj: object, stream_ptr: int | None=None) -> StridedMemoryView: 

233 """Create a view from an object supporting the `__cuda_array_interface__ <https://numba.readthedocs.io/en/stable/cuda/cuda_array_interface.html>`_ protocol. 

234  

235 Parameters 

236 ---------- 

237 obj : object 

238 An object implementing the `__cuda_array_interface__ <https://numba.readthedocs.io/en/stable/cuda/cuda_array_interface.html>`_ protocol. 

239 stream_ptr : int, optional 

240 Stream pointer for synchronization. If ``None``, no synchronization is performed. 

241 """ 

242 cdef StridedMemoryView buf = StridedMemoryView.__new__(cls) 5 ctx2v | Ib} 4

243 if _is_torch_tensor(obj): 5 ctx2v | Ib} 4

244 _get_tensor_bridge().view_as_torch_tensor(obj, stream_ptr, buf) 

245 return buf 

246 view_as_cai(obj, stream_ptr, buf) 6 ctx2z v | Ib} 4

247 return buf 4 ctx1v|}4

248  

249 @classmethod (empty)

250 def from_array_interface(cls, obj: object) -> StridedMemoryView: 

251 """Create a view from an object supporting the `__array_interface__ <https://numpy.org/doc/stable/reference/arrays.interface.html>`_ protocol. 

252  

253 Parameters 

254 ---------- 

255 obj : object 

256 An object implementing the `__array_interface__ <https://numpy.org/doc/stable/reference/arrays.interface.html>`_ protocol (e.g., a numpy array). 

257 """ 

258 cdef StridedMemoryView buf = StridedMemoryView.__new__(cls) 26 ctx2z ! # - $ . % ' ( ) * / : ; = ? @ [ ] ^ + _ ` { , Kb

259 if _is_torch_tensor(obj): 25 ctx2! # - $ . % ' ( ) * / : ; = ? @ [ ] ^ + _ ` { , Kb

260 _get_tensor_bridge().view_as_torch_tensor(obj, None, buf) 

261 return buf 

262 view_as_array_interface(obj, buf) 25 ctx2! # - $ . % ' ( ) * / : ; = ? @ [ ] ^ + _ ` { , Kb

263 return buf 25 ctx1z!#-$.%'()*/:;=?@[]^+_`{,

264  

265 @classmethod (empty)

266 def from_any_interface(cls, obj: object, stream_ptr: int | None = None) -> StridedMemoryView: 

267 """Create a view by automatically selecting the best available protocol. 

268  

269 Tries `DLPack <https://dmlc.github.io/dlpack/latest/>`_ first, then falls back to 

270 `__cuda_array_interface__ <https://numba.readthedocs.io/en/stable/cuda/cuda_array_interface.html>`_. 

271 ``torch.Tensor`` objects are transparently handled via a fast AOTI path 

272 regardless of which protocol is selected. 

273  

274 Parameters 

275 ---------- 

276 obj : object 

277 An object implementing `DLPack <https://dmlc.github.io/dlpack/latest/>`_ or 

278 `__cuda_array_interface__ <https://numba.readthedocs.io/en/stable/cuda/cuda_array_interface.html>`_. 

279 stream_ptr : int, optional 

280 Stream pointer for synchronization. If ``None``, no synchronization is performed. 

281 """ 

282 if check_has_dlpack(obj): 42 ctx21 2 3 8 V P Q R S T U Zbx y w 6 7 g I 5 H A b s d e h i j o p q r k l m n f u t c a

283 return cls.from_dlpack(obj, stream_ptr) 41 ctx11238VPQRSTUxyw67gI5HAbsdehijopqrklmnfutca

284 return cls.from_cuda_array_interface(obj, stream_ptr) 

285  

286 @classmethod (empty)

287 def from_buffer( 

288 cls, 

289 buffer : Buffer, 

290 shape : tuple[int, ...], 

291 strides : tuple[int, ...] | None = None, 

292 *, 

293 itemsize : int | None = None, (empty)

294 dtype : numpy.dtype | None = None, (empty)

295 is_readonly : bool = False (empty)

296 ) -> StridedMemoryView: 

297 """ 

298 Creates a :obj:`StridedMemoryView` instance from a :obj:`~_memory.Buffer` and shape and strides tuples. 

299 The Buffer can be either allocation coming from a :obj:`MemoryResource` or an external allocation 

300 wrapped in a :obj:`~_memory.Buffer` object with ``Buffer.from_handle(ptr, size, owner=...)``. 

301  

302 .. caution:: 

303 When creating a :obj:`StridedMemoryView` from a :obj:`~_memory.Buffer`, 

304 no synchronization is performed. It is the user's responsibility to ensure 

305 the data in ``buffer`` is properly synchronized when consuming the view. 

306  

307 Parameters 

308 ---------- 

309 buffer : :obj:`~_memory.Buffer` 

310 The buffer to create the view from. 

311 shape : :obj:`tuple` 

312 The layout describing the shape, strides and itemsize of the elements in 

313 the buffer. 

314 strides : :obj:`tuple` 

315 The layout describing the shape, strides and itemsize of the elements in 

316 the buffer. 

317 dtype : :obj:`numpy.dtype` 

318 Optional dtype. 

319 If specified, the dtype's itemsize must match the layout's itemsize. 

320 is_readonly : bool, optional 

321 Whether the mark the view as readonly. 

322 """ 

323 cdef StridedMemoryView view = StridedMemoryView.__new__(cls) 43 ctx2RbSbcbdbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbPbUbQbabbbNbJbO 9

324 if itemsize is None and dtype is None: 43 ctx2RbSbcbdbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbPbUbQbabbbNbJbO 9

325 raise ValueError("Either itemsize or dtype must be specified") 1 ctx2Ub

326 if itemsize is not None and dtype is not None and itemsize != dtype.itemsize: 42 ctx2RbSbcbdbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbPbQbabbbNbJbO 9

327 raise ValueError( 1 ctx2Qb

328 f"itemsize ({itemsize}) does not match dtype.itemsize ({dtype.itemsize})" 1 ctx2Qb

329 ) 

330 # (itemsize is None XOR dtype is None) OR they are equal 

331 view_buffer_strided( 39 ctx2cbdbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbPbabbbNbJbO 9

332 view, 

333 buffer, 

334 _StridedLayout(shape=shape, strides=strides, itemsize=getattr(dtype, "itemsize", itemsize)), 41 ctx2RbSbcbdbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbPbabbbNbJbO 9

335 dtype, 

336 is_readonly, 

337 ) 

338 return view 38 ctx2z cbdbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbabbbJbO 9

339  

340 def __dealloc__(self) -> None: 

341 if self.dl_tensor == NULL: 133 ctx2RbSb1 2 3 8 V P J K L M N Q R S T U W X Y Z 0 v x y w ! # - $ . % ' ( ) * / : ; = ? @ [ ] ^ + _ ` { , KbcbdbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbPbUbQbabbbNbJb| Ib} 6 7 g O Ob~ 9 I 5 H 4 B C D E F G A s d e h i j o p q r k l m n f u t c Lba Mb

342 return 88 ctx2RbSbv x y w ! # - $ . % ' ( ) * / : ; = ? @ [ ] ^ + _ ` { , KbcbdbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbPbUbQbabbbNbJb| Ib} O Ob~ 9 5 H 4 B C D E F G LbMb

343  

344 if cpython.PyCapsule_IsValid( 56 ctx11238VPJKLMNQRSTUWXYZ0xyw67gI5HBCDEFGAsdehijopqrklmnfutca

345 self.metadata, DLPACK_VERSIONED_TENSOR_USED_NAME): 56 ctx11238VPJKLMNQRSTUWXYZ0xyw67gI5HBCDEFGAsdehijopqrklmnfutca

346 data = cpython.PyCapsule_GetPointer( 56 ctx11238VPJKLMNQRSTUWXYZ0xyw67gI5HBCDEFGAsdehijopqrklmnfutca

347 self.metadata, DLPACK_VERSIONED_TENSOR_USED_NAME) 56 ctx11238VPJKLMNQRSTUWXYZ0xyw67gI5HBCDEFGAsdehijopqrklmnfutca

348 dlm_tensor_ver = <DLManagedTensorVersioned*>data 56 ctx11238VPJKLMNQRSTUWXYZ0xyw67gI5HBCDEFGAsdehijopqrklmnfutca

349 dlm_tensor_ver.deleter(dlm_tensor_ver) 56 ctx11238VPJKLMNQRSTUWXYZ0xyw67gI5HBCDEFGAsdehijopqrklmnfutca

350 elif cpython.PyCapsule_IsValid( 1 ctx1a

351 self.metadata, DLPACK_TENSOR_USED_NAME): 2 ctx1za

352 data = cpython.PyCapsule_GetPointer( 1 ctx1a

353 self.metadata, DLPACK_TENSOR_USED_NAME) 1 ctx1a

354 dlm_tensor = <DLManagedTensor*>data 1 ctx1a

355 dlm_tensor.deleter(dlm_tensor) 1 ctx1a

356  

357 def view( (empty)

358 self, layout : _StridedLayout | None = None, dtype : numpy.dtype | None = None 

359 ) -> StridedMemoryView: 

360 """ 

361 Creates a new view with adjusted layout and dtype. 

362 Same as calling :meth:`from_buffer` with the current buffer. 

363 """ 

364 cdef StridedMemoryView view = StridedMemoryView.__new__(self.__class__) 13 ctx2x y w abbb5 H B C D E F G

365 if layout is None and dtype is None: 14 ctx2z x y w abbb5 H B C D E F G

366 return self 1 ctx15

367 if layout is None: 12 ctx2x y w abbbH B C D E F G

368 layout = self.get_layout() 4 ctx1xywH

369 if dtype is None: 12 ctx2x y w abbbH B C D E F G

370 dtype = self.get_dtype() 9 ctx2z abbbB C D E F G

371 view_buffer_strided(view, self.get_buffer(), layout, dtype, self.readonly) 12 ctx2x y w abbbH B C D E F G

372 return view 12 ctx2x y w abbbH B C D E F G

373  

374 def as_tensor_map( (empty)

375 self, 

376 box_dim: tuple[int, ...] | None = None, 

377 *, 

378 options: object = None, (empty)

379 element_strides: tuple[int, ...] | None = None, (empty)

380 data_type: object = None, (empty)

381 interleave: object = None, (empty)

382 swizzle: object = None, (empty)

383 l2_promotion: object = None, (empty)

384 oob_fill: object = None, (empty)

385 ) -> object: 

386 """Create a tiled :obj:`TensorMapDescriptor` from this view. 

387  

388 This is the public entry point for creating tiled tensor map 

389 descriptors in ``cuda.core``. Pass either ``box_dim`` and the 

390 individual keyword arguments directly, or provide bundled tiled 

391 options via ``options=``. 

392 """ 

393 from cuda.core._tensor_map import TensorMapDescriptor 2 ctx1zP

394  

395 kwargs = {} 1 ctx1P

396 if options is not None: 1 ctx1P

397 kwargs["options"] = options 

398 if element_strides is not None: 1 ctx1P

399 kwargs["element_strides"] = element_strides 1 ctx1P

400 if data_type is not None: 1 ctx1P

401 kwargs["data_type"] = data_type 2 ctx1zP

402 if interleave is not None: 1 ctx1P

403 kwargs["interleave"] = interleave 

404 if swizzle is not None: 1 ctx1P

405 kwargs["swizzle"] = swizzle 1 ctx1P

406 if l2_promotion is not None: 1 ctx1P

407 kwargs["l2_promotion"] = l2_promotion 1 ctx1P

408 if oob_fill is not None: 1 ctx1P

409 kwargs["oob_fill"] = oob_fill 1 ctx1P

410 return TensorMapDescriptor._from_tiled(self, box_dim, **kwargs) 1 ctx1P

411  

412 def copy_from( (empty)

413 self, 

414 other: StridedMemoryView, 

415 stream: Stream, 

416 allocator: object = None, 

417 blocking: bool | None = None, 

418 ) -> None: 

419 """ 

420 Copies the data from the other view into this view. 

421  

422 The copy can be performed between following memory spaces: 

423 host-to-device, device-to-host, device-to-device (on the same device). 

424  

425 Parameters 

426 ---------- 

427 other : StridedMemoryView 

428 The view to copy data from. 

429 stream : Stream | None, optional 

430 The stream to schedule the copy on. 

431 allocator : MemoryResource | None, optional 

432 If temporary buffers are needed, the specified memory resources 

433 will be used to allocate the memory. If not specified, default 

434 resources will be used. 

435 blocking : bool | None, optional 

436 Whether the call should block until the copy is complete. 

437 * ``True``: the ``stream`` is synchronized with the host at the end of the call, 

438 blocking until the copy is complete. 

439 * ``False``: if possible, the call returns immediately once the copy is scheduled. 

440 However, in some cases of host-to-device or device-to-host copies, the call may 

441 still synchronize with the host if necessary. 

442 * ``None`` (default): 

443 * for device-to-device, it defaults to ``False`` (non-blocking), 

444 * for host-to-device or device-to-host, it defaults to ``True`` (blocking). 

445 """ 

446 raise NotImplementedError("Sorry, not supported: copy_from") 1 ctx16

447  

448 def copy_to( (empty)

449 self, 

450 other: StridedMemoryView, 

451 stream: Stream | None = None, 

452 allocator: object = None, 

453 blocking: bool | None = None, 

454 ) -> None: 

455 """ 

456 Copies the data from this view into the ``other`` view. 

457  

458 For details, see :meth:`copy_from`. 

459 """ 

460 raise NotImplementedError("Sorry, not supported: copy_to") 1 ctx17

461  

462 def __dlpack__( (empty)

463 self, 

464 *, 

465 stream: int | None = None, (empty)

466 max_version: tuple[int, int] | None = None, (empty)

467 dl_device: tuple[int, int] | None = None, (empty)

468 copy: bool | None = None, (empty)

469 ) -> object: 

470 # Similar to Buffer.__dlpack__: no implicit synchronization is performed. 

471 if dl_device is not None: 26 ctx13vxywgOsdehijopqrklmnfutca

472 raise BufferError("Sorry, not supported: dl_device other than None") 1 ctx13

473 if copy is True: 26 ctx13vxywgOsdehijopqrklmnfutca

474 raise BufferError("Sorry, not supported: copy=True") 1 ctx13

475  

476 cdef bint versioned 

477 if max_version is None: 26 ctx13vxywgOsdehijopqrklmnfutca

478 versioned = False 7 ctx1vxywOta

479 else: 

480 if not isinstance(max_version, tuple) or len(max_version) != 2: 20 ctx13gsdehijopqrklmnfuca

481 raise BufferError(f"Expected max_version tuple[int, int], got {max_version}") 2 ctx1z3

482 versioned = max_version >= (1, 0) 19 ctx1gsdehijopqrklmnfuca

483  

484 # NOTE: stream is accepted for protocol compatibility but not used. 

485 cdef object capsule = _smv_make_py_capsule(self, versioned) 25 ctx1vxywgOsdehijopqrklmnfutca

486 return capsule 21 ctx1vgsdehijopqrklmnfutca

487  

488 def __dlpack_device__(self) -> tuple[int, int]: (empty)

489 cdef _DLDeviceType device_type 

490 cdef int32_t device_id 

491 _smv_get_dl_device(self, &device_type, &device_id) 5 ctx112vga

492 return (<int>device_type, int(device_id)) 5 ctx112vga

493  

494 @property 

495 def _layout(self) -> _StridedLayout: 

496 """ 

497 The layout of the tensor. For StridedMemoryView created from DLPack or CAI, 

498 the layout is inferred from the tensor object's metadata. 

499 """ 

500 return self.get_layout() 42 ctx2cbdbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbabbbObH B C D E F G

501  

502 @property 

503 def size(self) -> int: 

504 return self.get_layout().get_volume() 40 ctx1JKLMNQRSTUWXYZ0!#-$.%'()*/:;=?@[]^+_`{,|

505  

506 @property 

507 def shape(self) -> tuple[int, ...]: 

508 """ 

509 Shape of the tensor. 

510 """ 

511 return self.get_layout().get_shape_tuple() 87 ctx2V J K L M N Q R S T U W X Y Z 0 ! # - $ . % ' ( ) * / : ; = ? @ [ ] ^ + _ ` { , cbdbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbabbb| } ~ 9 I 4 B C D E F G b

512  

513 @property 

514 def strides(self) -> tuple[int, ...] | None: 

515 """ 

516 Strides of the tensor (in **counts**, not bytes). 

517 """ 

518 return self.get_layout().get_strides_tuple() 76 ctx2V J K L M N Q R S T U W X Y Z 0 ! # - $ . % ' ( ) * / : ; = ? @ [ ] ^ + _ ` { , cbdbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHb| } 9 I

519  

520 @property 

521 def dtype(self) -> numpy.dtype | None: 

522 """ 

523 Data type of the tensor. 

524  

525 Supports standard NumPy dtypes as well as narrow data types (e.g., ``bfloat16``) 

526 when the optional `ml_dtypes <https://github.com/jax-ml/ml_dtypes>`_ package is 

527 installed. If ``ml_dtypes`` is not available and such a tensor is encountered, 

528 a :obj:`NotImplementedError` will be raised. 

529 """ 

530 return self.get_dtype() 66 ctx2! # - $ . % ' ( ) * / : ; = ? @ [ ] ^ + _ ` { , cbdbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbJb9 I H B C D E F G

531  

532 def __repr__(self) -> str: 

533 return (f"StridedMemoryView(ptr={self.ptr},\n" 2 ctx19I

534 + f" shape={self.shape},\n" 2 ctx19I

535 + f" strides={self.strides},\n" 2 ctx19I

536 + f" itemsize={self._layout.itemsize},\n" 2 ctx19I

537 + f" dtype={get_simple_repr(self.dtype)},\n" 2 ctx19I

538 + f" device_id={self.device_id},\n" 2 ctx19I

539 + f" is_device_accessible={self.is_device_accessible},\n" 2 ctx19I

540 + f" readonly={self.readonly},\n" 2 ctx19I

541 + f" exporting_obj={get_simple_repr(self.exporting_obj)})") 3 ctx1z9I

542  

543 @cython.critical_section (empty)

544 cdef inline _StridedLayout get_layout(self): 

545 if self._layout is None: 117 ctx2V J K L M N Q R S T U W X Y Z 0 v x y w ! # - $ . % ' ( ) * / : ; = ? @ [ ] ^ + _ ` { , KbcbdbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbabbb| Ib} g O Ob~ 9 I H 4 B C D E F G A b s d e h i j o p q r k l m n f u t c a

546 if self.dl_tensor: 81 ctx2V J K L M N Q R S T U W X Y Z 0 v x y w ! # - $ . % ' ( ) * / : ; = ? @ [ ] ^ + _ ` { , Kb| Ib} g Ob~ I H 4 B C D E F G A b s d e h i j o p q r k l m n f u t c a

547 self._layout = layout_from_dlpack(self.dl_tensor) 49 ctx1VJKLMNQRSTUWXYZ0xywgIHBCDEFGAbsdehijopqrklmnfutca

548 elif self.metadata is not None: 33 ctx2z v ! # - $ . % ' ( ) * / : ; = ? @ [ ] ^ + _ ` { , Kb| Ib} Ob~ 4

549 self._layout = layout_from_cai(self.metadata) 31 ctx2v ! # - $ . % ' ( ) * / : ; = ? @ [ ] ^ + _ ` { , Kb| Ib} ~ 4

550 else: 

551 raise ValueError("Cannot infer layout from the exporting object") 1 ctx2Ob

552 return self._layout 114 ctx2V J K L M N Q R S T U W X Y Z 0 v x y w ! # - $ . % ' ( ) * / : ; = ? @ [ ] ^ + _ ` { , cbdbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbabbb| } g O ~ 9 I H 4 B C D E F G A b s d e h i j o p q r k l m n f u t c a

553  

554 @cython.critical_section (empty)

555 cdef inline object get_buffer(self): 

556 """ 

557 Returns Buffer instance with the underlying data. 

558 If the SMV was created from a Buffer, it will return the same Buffer instance. 

559 Otherwise, it will create a new instance with owner set to the exporting object. 

560 """ 

561 if self._buffer is None: 13 ctx2v x y w abbbH B C D E F G

562 if isinstance(self.exporting_obj, Buffer): 11 ctx1vxywHBCDEFG

563 self._buffer = self.exporting_obj 

564 else: 

565 self._buffer = Buffer.from_handle(self.ptr, 0, owner=self.exporting_obj) 12 ctx1zvxywHBCDEFG

566 return self._buffer 13 ctx2v x y w abbbH B C D E F G

567  

568 @cython.critical_section (empty)

569 cdef inline object get_dtype(self): 

570 if self._dtype is None: 95 ctx2v x y w ! # - $ . % ' ( ) * / : ; = ? @ [ ] ^ + _ ` { , cbdbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbabbbJbg O 9 I H B C D E F G A b s d e h i j o p q r k l m n f u t c a

571 if self.dl_tensor != NULL: 56 ctx1v!#-$.%'()*/:;=?@[]^+_`{,gO9IBCDEFGAbsdehijopqrklmnfutca

572 self._dtype = dtype_dlpack_to_numpy(&self.dl_tensor.dtype) 29 ctx1gIBCDEFGAbsdehijopqrklmnfutca

573 elif isinstance(self.metadata, int): 27 ctx1v!#-$.%'()*/:;=?@[]^+_`{,O9

574 # AOTI dtype code stored by the torch tensor bridge 

575 self._dtype = _get_tensor_bridge().resolve_aoti_dtype( 

576 self.metadata) 

577 elif self.metadata is not None: 27 ctx1v!#-$.%'()*/:;=?@[]^+_`{,O9

578 self._dtype = _typestr2dtype(self.metadata["typestr"]) 25 ctx1v!#-$.%'()*/:;=?@[]^+_`{,

579 return self._dtype 95 ctx2v x y w ! # - $ . % ' ( ) * / : ; = ? @ [ ] ^ + _ ` { , cbdbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbabbbJbg O 9 I H B C D E F G A b s d e h i j o p q r k l m n f u t c a

580  

581  

582cdef void _smv_pycapsule_deleter(object capsule) noexcept: (empty)

583 cdef DLManagedTensor* dlm_tensor 

584 cdef DLManagedTensorVersioned* dlm_tensor_ver 

585 # Do not invoke the deleter on a used capsule. 

586 if cpython.PyCapsule_IsValid(capsule, DLPACK_TENSOR_UNUSED_NAME): 21 ctx1vgsdehijopqrklmnfutca

587 dlm_tensor = <DLManagedTensor*>( 3 ctx1zvt

588 cpython.PyCapsule_GetPointer(capsule, DLPACK_TENSOR_UNUSED_NAME) 2 ctx1vt

589 ) 

590 if dlm_tensor.deleter: 2 ctx1vt

591 dlm_tensor.deleter(dlm_tensor) 3 ctx1zvt

592 elif cpython.PyCapsule_IsValid(capsule, DLPACK_VERSIONED_TENSOR_UNUSED_NAME): 19 ctx1gsdehijopqrklmnfuca

593 dlm_tensor_ver = <DLManagedTensorVersioned*>( 1 ctx1c

594 cpython.PyCapsule_GetPointer(capsule, DLPACK_VERSIONED_TENSOR_UNUSED_NAME) 1 ctx1c

595 ) 

596 if dlm_tensor_ver.deleter: 1 ctx1c

597 dlm_tensor_ver.deleter(dlm_tensor_ver) 1 ctx1c

598  

599  

600cdef inline void _smv_release_export_resources(void* manager_ctx, int64_t* shape_ptr) noexcept with gil: (empty)

601 if shape_ptr: 25 ctx1vxywgOsdehijopqrklmnfutca

602 stdlib.free(shape_ptr) 20 ctx1vgsdehijopqrklmnftca

603 if manager_ctx: 25 ctx1vxywgOsdehijopqrklmnfutca

604 cpython.Py_DECREF(<object>manager_ctx) 25 ctx1vxywgOsdehijopqrklmnfutca

605  

606  

607cdef void _smv_deleter(DLManagedTensor* tensor) noexcept with gil: (empty)

608 if tensor: 7 ctx1vxywOta

609 _smv_release_export_resources(tensor.manager_ctx, tensor.dl_tensor.shape) 8 ctx1zvxywOta

610 tensor.manager_ctx = NULL 7 ctx1vxywOta

611 stdlib.free(tensor) 7 ctx1vxywOta

612  

613  

614cdef void _smv_versioned_deleter(DLManagedTensorVersioned* tensor) noexcept with gil: (empty)

615 if tensor: 23 ctx1xywgOsdehijopqrklmnfuca

616 _smv_release_export_resources(tensor.manager_ctx, tensor.dl_tensor.shape) 19 ctx1gsdehijopqrklmnfuca

617 tensor.manager_ctx = NULL 19 ctx1gsdehijopqrklmnfuca

618 stdlib.free(tensor) 19 ctx1gsdehijopqrklmnfuca

619  

620  

621cdef inline DLManagedTensorVersioned* _smv_allocate_dlm_tensor_versioned() except? NULL: (empty)

622 cdef DLManagedTensorVersioned* dlm_tensor_ver = NULL 20 ctx1gbsdehijopqrklmnfuca

623 dlm_tensor_ver = <DLManagedTensorVersioned*>stdlib.malloc(sizeof(DLManagedTensorVersioned)) 20 ctx1gbsdehijopqrklmnfuca

624 if dlm_tensor_ver == NULL: 20 ctx1gbsdehijopqrklmnfuca

625 raise MemoryError() 

626 dlm_tensor_ver.dl_tensor.shape = NULL 20 ctx1gbsdehijopqrklmnfuca

627 dlm_tensor_ver.manager_ctx = NULL 20 ctx1gbsdehijopqrklmnfuca

628 return dlm_tensor_ver 20 ctx1gbsdehijopqrklmnfuca

629  

630  

631cdef inline DLManagedTensor* _smv_allocate_dlm_tensor() except? NULL: (empty)

632 cdef DLManagedTensor* dlm_tensor = NULL 8 ctx1zvxywOta

633 dlm_tensor = <DLManagedTensor*>stdlib.malloc(sizeof(DLManagedTensor)) 7 ctx1vxywOta

634 if dlm_tensor == NULL: 7 ctx1vxywOta

635 raise MemoryError() 

636 dlm_tensor.dl_tensor.shape = NULL 7 ctx1vxywOta

637 dlm_tensor.manager_ctx = NULL 7 ctx1vxywOta

638 return dlm_tensor 7 ctx1vxywOta

639  

640  

641cdef inline int _smv_dtype_numpy_to_dlpack(object dtype_obj, DLDataType* out_dtype) except -1: (empty)

642 cdef object np_dtype = numpy.dtype(dtype_obj) 26 ctx1vxywgAbsdehijopqrklmnfutca

643 if np_dtype.fields is not None: 26 ctx1vxywgAbsdehijopqrklmnfutca

644 raise BufferError("Structured dtypes are not supported for DLPack export") 1 ctx1y

645 if not np_dtype.isnative and np_dtype.byteorder not in ("=", "|"): 25 ctx1vxwgAbsdehijopqrklmnfutca

646 raise BufferError("Non-native-endian dtypes are not supported for DLPack export") 1 ctx1x

647  

648 cdef str kind = np_dtype.kind 25 ctx1zvwgAbsdehijopqrklmnfutca

649 cdef int bits = np_dtype.itemsize * 8 24 ctx1vwgAbsdehijopqrklmnfutca

650 cdef uint8_t code 

651 if kind == "b": 24 ctx1vwgAbsdehijopqrklmnfutca

652 if bits != 8: 1 ctx1s

653 raise BufferError(f"Unsupported bool dtype itemsize: {np_dtype.itemsize}") 

654 code = <uint8_t>kDLBool 1 ctx1s

655 elif kind == "i": 23 ctx1vwgAbdehijopqrklmnfutca

656 if bits not in (8, 16, 32, 64): 9 ctx1gAopqrtca

657 raise BufferError(f"Unsupported signed integer dtype: {np_dtype}") 

658 code = <uint8_t>kDLInt 9 ctx1gAopqrtca

659 elif kind == "u": 14 ctx1vwbdehijklmnfu

660 if bits not in (8, 16, 32, 64): 4 ctx1klmn

661 raise BufferError(f"Unsupported unsigned integer dtype: {np_dtype}") 

662 code = <uint8_t>kDLUInt 4 ctx1klmn

663 elif kind == "f": 10 ctx1vwbdehijfu

664 if bits not in (16, 32, 64): 5 ctx1vbhij

665 raise BufferError(f"Unsupported floating dtype: {np_dtype}") 

666 code = <uint8_t>kDLFloat 5 ctx1vbhij

667 elif kind == "c": 5 ctx1wdefu

668 if bits not in (64, 128): 5 ctx1zdefu

669 raise BufferError(f"Unsupported complex dtype: {np_dtype}") 

670 code = <uint8_t>kDLComplex 4 ctx1defu

671 else: 

672 raise BufferError(f"Unsupported dtype for DLPack export: {np_dtype}") 1 ctx1w

673  

674 out_dtype.code = code 23 ctx1vgAbsdehijopqrklmnfutca

675 out_dtype.bits = <uint8_t>bits 23 ctx1vgAbsdehijopqrklmnfutca

676 out_dtype.lanes = <uint16_t>1 23 ctx1vgAbsdehijopqrklmnfutca

677 return 0 23 ctx1vgAbsdehijopqrklmnfutca

678  

679  

680cdef inline int _smv_get_dl_device( (empty)

681 StridedMemoryView view, 

682 _DLDeviceType* out_device_type, 

683 int32_t* out_device_id, 

684) except -1: 

685 cdef _DLDeviceType device_type 

686 cdef int32_t device_id 

687 cdef object buf 

688 if view.dl_tensor != NULL: 25 ctx112vgAbsdehijopqrklmnfutca

689 device_type = view.dl_tensor.device.device_type 24 ctx112gAbsdehijopqrklmnfutca

690 if device_type == _kDLCUDA: 24 ctx112gAbsdehijopqrklmnfutca

691 device_id = view.dl_tensor.device.device_id 

692 else: 

693 # CPU, CUDAHost, and CUDAManaged use device_id=0 in DLPack. 

694 device_id = 0 24 ctx112gAbsdehijopqrklmnfutca

695 elif view.is_device_accessible: 1 ctx1v

696 buf = view.get_buffer() 1 ctx1v

697 dev_type, dev_id = classify_dl_device(buf) 1 ctx1v

698 device_type = <_DLDeviceType>dev_type 1 ctx1v

699 device_id = <int32_t>dev_id 1 ctx1v

700 else: 

701 device_type = _kDLCPU 

702 device_id = 0 

703  

704 out_device_type[0] = device_type 25 ctx112vgAbsdehijopqrklmnfutca

705 out_device_id[0] = device_id 25 ctx112vgAbsdehijopqrklmnfutca

706 return 0 25 ctx112vgAbsdehijopqrklmnfutca

707  

708  

709cdef inline int _smv_setup_dl_tensor_common( (empty)

710 DLTensor* dl_tensor, 

711 StridedMemoryView view, 

712 _StridedLayout layout, 

713) except -1: 

714 cdef object dtype_obj = view.get_dtype() 27 ctx1vxywgOAbsdehijopqrklmnfutca

715 if dtype_obj is None: 27 ctx1vxywgOAbsdehijopqrklmnfutca

716 raise BufferError( 1 ctx1O

717 "Cannot export StridedMemoryView via DLPack without dtype information; " 

718 "create the view with dtype specified." 

719 ) 

720 _smv_dtype_numpy_to_dlpack(dtype_obj, &dl_tensor.dtype) 26 ctx1vxywgAbsdehijopqrklmnfutca

721 _smv_get_dl_device(view, &dl_tensor.device.device_type, &dl_tensor.device.device_id) 23 ctx1vgAbsdehijopqrklmnfutca

722  

723 cdef int ndim = layout.base.ndim 23 ctx1vgAbsdehijopqrklmnfutca

724 dl_tensor.ndim = ndim 23 ctx1vgAbsdehijopqrklmnfutca

725 if layout.get_volume() == 0: 23 ctx1vgAbsdehijopqrklmnfutca

726 dl_tensor.data = NULL 1 ctx1f

727 else: 

728 dl_tensor.data = <void*><intptr_t>view.ptr 22 ctx1vgAbsdehijopqrklmnutca

729 dl_tensor.byte_offset = 0 23 ctx1vgAbsdehijopqrklmnfutca

730 return 0 23 ctx1vgAbsdehijopqrklmnfutca

731  

732  

733cdef inline int _smv_setup_dl_tensor(DLTensor* dl_tensor, StridedMemoryView view) except -1: (empty)

734 cdef _StridedLayout layout = view.get_layout() 26 ctx1vxywgObsdehijopqrklmnfutca

735 _smv_setup_dl_tensor_common(dl_tensor, view, layout) 26 ctx1vxywgObsdehijopqrklmnfutca

736  

737 cdef int i 

738 cdef int64_t* shape_strides = NULL 22 ctx1vgbsdehijopqrklmnfutca

739 cdef int64_t* strides_src = NULL 22 ctx1vgbsdehijopqrklmnfutca

740 cdef int ndim = dl_tensor.ndim 22 ctx1vgbsdehijopqrklmnfutca

741 if ndim == 0: 22 ctx1vgbsdehijopqrklmnfutca

742 dl_tensor.shape = NULL 1 ctx1u

743 dl_tensor.strides = NULL 1 ctx1u

744 else: 

745 # DLPack v1.2+ requires non-NULL strides for ndim != 0. 

746 shape_strides = <int64_t*>stdlib.malloc(sizeof(int64_t) * 2 * ndim) 21 ctx1vgbsdehijopqrklmnftca

747 if shape_strides == NULL: 21 ctx1vgbsdehijopqrklmnftca

748 raise MemoryError() 

749 try: 21 ctx1vgbsdehijopqrklmnftca

750 strides_src = get_strides_ptr(layout.base) 21 ctx1vgbsdehijopqrklmnftca

751 for i in range(ndim): 21 ctx1vgbsdehijopqrklmnftca

752 shape_strides[i] = layout.base.shape[i] 21 ctx1vgbsdehijopqrklmnftca

753 shape_strides[i + ndim] = strides_src[i] 21 ctx1vgbsdehijopqrklmnftca

754 except Exception: 

755 stdlib.free(shape_strides) 

756 raise 

757 dl_tensor.shape = shape_strides 21 ctx1vgbsdehijopqrklmnftca

758 dl_tensor.strides = shape_strides + ndim 21 ctx1vgbsdehijopqrklmnftca

759 return 0 22 ctx1vgbsdehijopqrklmnfutca

760  

761  

762cdef inline int _smv_setup_dltensor_borrowed(DLTensor* dl_tensor, StridedMemoryView view) except -1: (empty)

763 cdef _StridedLayout layout = view.get_layout() 1 ctx1A

764 _smv_setup_dl_tensor_common(dl_tensor, view, layout) 1 ctx1A

765  

766 if dl_tensor.ndim == 0: 1 ctx1A

767 dl_tensor.shape = NULL 

768 dl_tensor.strides = NULL 

769 else: 

770 dl_tensor.shape = layout.base.shape 1 ctx1A

771 # For temporary/non-owning exchange we provide explicit strides. 

772 dl_tensor.strides = get_strides_ptr(layout.base) 1 ctx1A

773 return 0 1 ctx1A

774  

775  

776cdef inline int _smv_fill_managed_tensor_versioned( (empty)

777 DLManagedTensorVersioned* dlm_tensor_ver, 

778 StridedMemoryView view, 

779) except -1: 

780 cpython.Py_INCREF(view) 20 ctx1gbsdehijopqrklmnfuca

781 dlm_tensor_ver.manager_ctx = <void*>view 20 ctx1gbsdehijopqrklmnfuca

782 dlm_tensor_ver.deleter = _smv_versioned_deleter 20 ctx1gbsdehijopqrklmnfuca

783 dlm_tensor_ver.version.major = DLPACK_MAJOR_VERSION 20 ctx1gbsdehijopqrklmnfuca

784 dlm_tensor_ver.version.minor = DLPACK_MINOR_VERSION 20 ctx1gbsdehijopqrklmnfuca

785 dlm_tensor_ver.flags = DLPACK_FLAG_BITMASK_READ_ONLY if view.readonly else 0 20 ctx1gbsdehijopqrklmnfuca

786 _smv_setup_dl_tensor(&dlm_tensor_ver.dl_tensor, view) 20 ctx1gbsdehijopqrklmnfuca

787 return 0 20 ctx1gbsdehijopqrklmnfuca

788  

789  

790cdef inline int _smv_fill_managed_tensor( (empty)

791 DLManagedTensor* dlm_tensor, 

792 StridedMemoryView view, 

793) except -1: 

794 cpython.Py_INCREF(view) 7 ctx1vxywOta

795 dlm_tensor.manager_ctx = <void*>view 7 ctx1vxywOta

796 dlm_tensor.deleter = _smv_deleter 7 ctx1vxywOta

797 _smv_setup_dl_tensor(&dlm_tensor.dl_tensor, view) 7 ctx1vxywOta

798 return 0 3 ctx1vta

799  

800  

801cdef object _smv_make_py_capsule(StridedMemoryView view, bint versioned): (empty)

802 cdef DLManagedTensor* dlm_tensor = NULL 25 ctx1vxywgOsdehijopqrklmnfutca

803 cdef DLManagedTensorVersioned* dlm_tensor_ver = NULL 25 ctx1vxywgOsdehijopqrklmnfutca

804 cdef object capsule = None 25 ctx1vxywgOsdehijopqrklmnfutca

805 cdef void* tensor_ptr = NULL 25 ctx1vxywgOsdehijopqrklmnfutca

806 cdef const char* capsule_name 

807 try: 25 ctx1vxywgOsdehijopqrklmnfutca

808 if versioned: 25 ctx1vxywgOsdehijopqrklmnfutca

809 dlm_tensor_ver = _smv_allocate_dlm_tensor_versioned() 19 ctx1gsdehijopqrklmnfuca

810 _smv_fill_managed_tensor_versioned(dlm_tensor_ver, view) 19 ctx1gsdehijopqrklmnfuca

811 tensor_ptr = <void*>dlm_tensor_ver 19 ctx1gsdehijopqrklmnfuca

812 capsule_name = DLPACK_VERSIONED_TENSOR_UNUSED_NAME 19 ctx1gsdehijopqrklmnfuca

813 else: 

814 dlm_tensor = _smv_allocate_dlm_tensor() 7 ctx1vxywOta

815 _smv_fill_managed_tensor(dlm_tensor, view) 7 ctx1vxywOta

816 tensor_ptr = <void*>dlm_tensor 3 ctx1vta

817 capsule_name = DLPACK_TENSOR_UNUSED_NAME 3 ctx1vta

818 capsule = cpython.PyCapsule_New(tensor_ptr, capsule_name, _smv_pycapsule_deleter) 21 ctx1vgsdehijopqrklmnfutca

819 except Exception: 4 ctx1xywO

820 if capsule is None: 4 ctx1xywO

821 _smv_deleter(dlm_tensor) 4 ctx1xywO

822 _smv_versioned_deleter(dlm_tensor_ver) 4 ctx1xywO

823 raise 4 ctx1xywO

824 return capsule 21 ctx1vgsdehijopqrklmnfutca

825  

826  

827cdef inline StridedMemoryView _smv_from_dlpack_capsule(object capsule, object exporting_obj): (empty)

828 cdef void* data = NULL 1 ctx1b

829 cdef DLTensor* dl_tensor = NULL 1 ctx1b

830 cdef DLManagedTensorVersioned* dlm_tensor_ver = NULL 1 ctx1b

831 cdef DLManagedTensor* dlm_tensor = NULL 1 ctx1b

832 cdef bint is_readonly = False 1 ctx1b

833 cdef const char* used_name = NULL 1 ctx1b

834 if cpython.PyCapsule_IsValid(capsule, DLPACK_VERSIONED_TENSOR_UNUSED_NAME): 1 ctx1b

835 data = cpython.PyCapsule_GetPointer(capsule, DLPACK_VERSIONED_TENSOR_UNUSED_NAME) 1 ctx1b

836 dlm_tensor_ver = <DLManagedTensorVersioned*>data 1 ctx1b

837 dl_tensor = &dlm_tensor_ver.dl_tensor 1 ctx1b

838 is_readonly = bool((dlm_tensor_ver.flags & DLPACK_FLAG_BITMASK_READ_ONLY) != 0) 1 ctx1b

839 used_name = DLPACK_VERSIONED_TENSOR_USED_NAME 1 ctx1b

840 elif cpython.PyCapsule_IsValid(capsule, DLPACK_TENSOR_UNUSED_NAME): 

841 data = cpython.PyCapsule_GetPointer(capsule, DLPACK_TENSOR_UNUSED_NAME) 

842 dlm_tensor = <DLManagedTensor*>data 

843 dl_tensor = &dlm_tensor.dl_tensor 

844 is_readonly = False 

845 used_name = DLPACK_TENSOR_USED_NAME 

846 else: 

847 raise BufferError("Invalid DLPack capsule") 

848  

849 cpython.PyCapsule_SetName(capsule, used_name) 1 ctx1b

850  

851 cdef StridedMemoryView view = StridedMemoryView.__new__(StridedMemoryView) 1 ctx1b

852 view.dl_tensor = dl_tensor 1 ctx1b

853 view.metadata = capsule 1 ctx1b

854 view.ptr = <intptr_t>(dl_tensor.data) + <intptr_t>(dl_tensor.byte_offset) 1 ctx1b

855 view.readonly = is_readonly 1 ctx1b

856 view.exporting_obj = exporting_obj 1 ctx1b

857 if dl_tensor.device.device_type == _kDLCPU: 1 ctx1b

858 view.device_id = -1 1 ctx1b

859 view.is_device_accessible = False 1 ctx1b

860 elif dl_tensor.device.device_type in (_kDLCUDA, _kDLCUDAHost, _kDLCUDAManaged): 

861 view.device_id = dl_tensor.device.device_id 

862 view.is_device_accessible = True 

863 else: 

864 raise BufferError("device not supported") 

865 return view 1 ctx1b

866  

867  

868cdef int _smv_managed_tensor_allocator( (empty)

869 DLTensor* prototype, 

870 DLManagedTensorVersioned** out, 

871 void* error_ctx, 

872 void (*SetError)(void* error_ctx, const char* kind, const char* message) noexcept, 

873) noexcept with gil: 

874 if out != NULL: 1 ctx2Vb

875 out[0] = NULL 1 ctx2Vb

876 if SetError != NULL: 1 ctx2Vb

877 SetError(error_ctx, b"NotImplementedError", b"managed_tensor_allocator is not supported by StridedMemoryView") 

878 cpython.PyErr_SetString(NotImplementedError, b"managed_tensor_allocator is not supported by StridedMemoryView") 1 ctx2Vb

879 return -1 1 ctx2Vb

880  

881  

882cdef int _smv_managed_tensor_from_py_object_no_sync( (empty)

883 void* py_object, 

884 DLManagedTensorVersioned** out, 

885) noexcept with gil: 

886 cdef DLManagedTensorVersioned* dlm_tensor_ver = NULL 1 ctx1b

887 if out == NULL: 1 ctx1b

888 cpython.PyErr_SetString(RuntimeError, b"out cannot be NULL") 

889 return -1 

890 out[0] = NULL 1 ctx1b

891 cdef object obj = <object>py_object 1 ctx1b

892 if not isinstance(obj, StridedMemoryView): 1 ctx1b

893 cpython.PyErr_SetString(TypeError, b"py_object must be a StridedMemoryView") 

894 return -1 

895 try: 1 ctx1b

896 dlm_tensor_ver = _smv_allocate_dlm_tensor_versioned() 1 ctx1b

897 _smv_fill_managed_tensor_versioned(dlm_tensor_ver, <StridedMemoryView>obj) 1 ctx1b

898 except Exception: 

899 _smv_versioned_deleter(dlm_tensor_ver) 

900 return -1 

901 out[0] = dlm_tensor_ver 1 ctx1b

902 return 0 1 ctx1b

903  

904  

905cdef int _smv_managed_tensor_to_py_object_no_sync( (empty)

906 DLManagedTensorVersioned* tensor, 

907 void** out_py_object, 

908) noexcept with gil: 

909 cdef object capsule 

910 cdef object py_view 

911 if out_py_object == NULL: 2 ctx2b Wb

912 cpython.PyErr_SetString(RuntimeError, b"out_py_object cannot be NULL") 

913 return -1 

914 out_py_object[0] = NULL 2 ctx2b Wb

915 if tensor == NULL: 2 ctx2b Wb

916 cpython.PyErr_SetString(RuntimeError, b"tensor cannot be NULL") 1 ctx2Wb

917 return -1 1 ctx2Wb

918 try: 1 ctx1b

919 capsule = cpython.PyCapsule_New( 1 ctx1b

920 <void*>tensor, 

921 DLPACK_VERSIONED_TENSOR_UNUSED_NAME, 

922 _smv_pycapsule_deleter, 

923 ) 

924 py_view = _smv_from_dlpack_capsule(capsule, capsule) 1 ctx1b

925 cpython.Py_INCREF(py_view) 1 ctx1b

926 out_py_object[0] = <void*>py_view 1 ctx1b

927 except Exception: 

928 return -1 

929 return 0 1 ctx1b

930  

931  

932cdef int _smv_dltensor_from_py_object_no_sync( (empty)

933 void* py_object, 

934 DLTensor* out, 

935) noexcept with gil: 

936 if out == NULL: 2 ctx2XbA

937 cpython.PyErr_SetString(RuntimeError, b"out cannot be NULL") 

938 return -1 

939 cdef object obj = <object>py_object 2 ctx2XbA

940 if not isinstance(obj, StridedMemoryView): 2 ctx2XbA

941 cpython.PyErr_SetString(TypeError, b"py_object must be a StridedMemoryView") 1 ctx2Xb

942 return -1 1 ctx2Xb

943 try: 1 ctx1A

944 _smv_setup_dltensor_borrowed(out, <StridedMemoryView>obj) 1 ctx1A

945 except Exception: 

946 return -1 

947 return 0 1 ctx1A

948  

949  

950cdef int _smv_current_work_stream( (empty)

951 _DLDeviceType device_type, 

952 int32_t device_id, 

953 void** out_current_stream, 

954) noexcept with gil: 

955 if out_current_stream == NULL: 1 ctx22b

956 cpython.PyErr_SetString(RuntimeError, b"out_current_stream cannot be NULL") 

957 return -1 

958 # cuda.core has no global/current stream state today. 

959 out_current_stream[0] = NULL 1 ctx22b

960 return 0 1 ctx22b

961  

962  

963cdef void _init_smv_dlpack_exchange_api(): (empty)

964 global _SMV_DLPACK_EXCHANGE_API_INITED 

965 if _SMV_DLPACK_EXCHANGE_API_INITED: (empty)

966 return 

967 _SMV_DLPACK_EXCHANGE_API.header.version.major = DLPACK_MAJOR_VERSION (empty)

968 _SMV_DLPACK_EXCHANGE_API.header.version.minor = DLPACK_MINOR_VERSION (empty)

969 _SMV_DLPACK_EXCHANGE_API.header.prev_api = NULL (empty)

970 _SMV_DLPACK_EXCHANGE_API.managed_tensor_allocator = _smv_managed_tensor_allocator (empty)

971 _SMV_DLPACK_EXCHANGE_API.managed_tensor_from_py_object_no_sync = _smv_managed_tensor_from_py_object_no_sync (empty)

972 _SMV_DLPACK_EXCHANGE_API.managed_tensor_to_py_object_no_sync = _smv_managed_tensor_to_py_object_no_sync (empty)

973 _SMV_DLPACK_EXCHANGE_API.dltensor_from_py_object_no_sync = _smv_dltensor_from_py_object_no_sync (empty)

974 _SMV_DLPACK_EXCHANGE_API.current_work_stream = _smv_current_work_stream (empty)

975 _SMV_DLPACK_EXCHANGE_API_INITED = True (empty)

976  

977  

978_init_smv_dlpack_exchange_api() (empty)

979# cdef classes are immutable types in Cython 3, so inject these attributes 

980# directly into the type dict. 

981(<dict>(<PyTypeObject*>StridedMemoryView).tp_dict)["__dlpack_c_exchange_api__"] = _SMV_DLPACK_EXCHANGE_API_CAPSULE (empty)

982(<dict>(<PyTypeObject*>StridedMemoryView).tp_dict)["__c_dlpack_exchange_api__"] = _SMV_DLPACK_EXCHANGE_API_CAPSULE (empty)

983PyType_Modified(<PyTypeObject*>StridedMemoryView) (empty)

984  

985  

986cdef str get_simple_repr(obj): (empty)

987 # TODO: better handling in np.dtype objects 

988 cdef object obj_class 

989 cdef str obj_repr 

990 if isinstance(obj, type): 2 ctx19I

991 obj_class = obj 

992 else: 

993 obj_class = obj.__class__ 2 ctx19I

994 if obj_class.__module__ in (None, "builtins"): 2 ctx19I

995 obj_repr = obj_class.__name__ 1 ctx19

996 else: 

997 obj_repr = f"{obj_class.__module__}.{obj_class.__name__}" 2 ctx19I

998 return obj_repr 2 ctx19I

999  

1000  

1001  

1002cdef bint check_has_dlpack(obj) except*: (empty)

1003 cdef bint has_dlpack 

1004 if hasattr(obj, "__dlpack__") and hasattr(obj, "__dlpack_device__"): 54 ctx21 2 3 8 V P J K L M N Q R S T U W X Y Z 0 Zbx y w 6 7 g ~ TbI 5 H A b s d e h i j o p q r k l m n f u t c a

1005 has_dlpack = True 51 ctx11238VPJKLMNQRSTUWXYZ0xyw67gI5HAbsdehijopqrklmnfutca

1006 elif hasattr(obj, "__cuda_array_interface__"): 3 ctx2Zb~ Tb

1007 has_dlpack = False 2 ctx2~ Tb

1008 else: 

1009 raise BufferError( 1 ctx2Zb

1010 "the input object does not support any data exchange protocol") 

1011 return has_dlpack 53 ctx21 2 3 8 V P J K L M N Q R S T U W X Y Z 0 x y w 6 7 g ~ TbI 5 H A b s d e h i j o p q r k l m n f u t c a

1012  

1013  

1014cdef class _StridedMemoryViewProxy: 

1015 cdef readonly: 

1016 object obj 

1017 bint has_dlpack 

1018  

1019 def __init__(self, obj: object) -> None: 

1020 self.obj = obj 6 ctx2J K L M N Tb

1021 self.has_dlpack = check_has_dlpack(obj) 6 ctx2J K L M N Tb

1022  

1023 cpdef StridedMemoryView view(self, stream_ptr=None): (empty)

1024 if self.has_dlpack: 5 ctx1JKLMN

1025 return StridedMemoryView.from_dlpack(self.obj, stream_ptr) 5 ctx1JKLMN

1026 else: 

1027 return StridedMemoryView.from_cuda_array_interface(self.obj, stream_ptr) 

1028  

1029  

1030cdef StridedMemoryView view_as_dlpack(obj, stream_ptr, view=None): (empty)

1031 cdef int dldevice, device_id 

1032 cdef bint is_device_accessible, is_readonly 

1033 is_device_accessible = False 59 ctx21 2 3 8 V P J K L M N Q R S T U W X Y Z 0 x y w 6 7 g I 5 H B C D E F G A b s d e h i j o p q r k l m n f u t c Lba Mb

1034 dldevice, device_id = obj.__dlpack_device__() 59 ctx21 2 3 8 V P J K L M N Q R S T U W X Y Z 0 x y w 6 7 g I 5 H B C D E F G A b s d e h i j o p q r k l m n f u t c Lba Mb

1035 if dldevice == _kDLCPU: 59 ctx21 2 3 8 V P J K L M N Q R S T U W X Y Z 0 x y w 6 7 g I 5 H B C D E F G A b s d e h i j o p q r k l m n f u t c Lba Mb

1036 assert device_id == 0 56 ctx23 8 V P J K L M N Q R S T U W X Y Z 0 x y w 6 7 g I 5 H B C D E F G A b s d e h i j o p q r k l m n f u t c Lba

1037 device_id = -1 56 ctx23 8 V P J K L M N Q R S T U W X Y Z 0 x y w 6 7 g I 5 H B C D E F G A b s d e h i j o p q r k l m n f u t c Lba

1038 if stream_ptr is None: 56 ctx23 8 V P J K L M N Q R S T U W X Y Z 0 x y w 6 7 g I 5 H B C D E F G A b s d e h i j o p q r k l m n f u t c Lba

1039 raise BufferError("stream=None is ambiguous with view()") 1 ctx2Lb

1040 elif stream_ptr == -1: 55 ctx138VPJKLMNQRSTUWXYZ0xyw67gI5HBCDEFGAbsdehijopqrklmnfutca

1041 stream_ptr = None 55 ctx138VPJKLMNQRSTUWXYZ0xyw67gI5HBCDEFGAbsdehijopqrklmnfutca

1042 elif dldevice == _kDLCUDA: 

1043 assert device_id >= 0 

1044 is_device_accessible = True 

1045 # no need to check other stream values, it's a pass-through 

1046 if stream_ptr is None: 

1047 raise BufferError("stream=None is ambiguous with view()") 

1048 elif dldevice in (_kDLCUDAHost, _kDLCUDAManaged): 

1049 is_device_accessible = True 2 ctx112

1050 # just do a pass-through without any checks, as pinned/managed memory can be 

1051 # accessed on both host and device 

1052 else: 

1053 raise BufferError("device not supported") 1 ctx2Mb

1054  

1055 cdef object capsule 

1056 try: 57 ctx11238VPJKLMNQRSTUWXYZ0xyw67gI5HBCDEFGAbsdehijopqrklmnfutca

1057 capsule = obj.__dlpack__( 57 ctx11238VPJKLMNQRSTUWXYZ0xyw67gI5HBCDEFGAbsdehijopqrklmnfutca

1058 stream=int(stream_ptr) if stream_ptr else None, 57 ctx11238VPJKLMNQRSTUWXYZ0xyw67gI5HBCDEFGAbsdehijopqrklmnfutca

1059 max_version=(DLPACK_MAJOR_VERSION, DLPACK_MINOR_VERSION)) 57 ctx11238VPJKLMNQRSTUWXYZ0xyw67gI5HBCDEFGAbsdehijopqrklmnfutca

1060 except TypeError: 1 ctx1a

1061 capsule = obj.__dlpack__( 1 ctx1a

1062 stream=int(stream_ptr) if stream_ptr else None) 1 ctx1a

1063  

1064 cdef void* data = NULL 57 ctx11238VPJKLMNQRSTUWXYZ0xyw67gI5HBCDEFGAbsdehijopqrklmnfutca

1065 cdef DLTensor* dl_tensor 

1066 cdef DLManagedTensorVersioned* dlm_tensor_ver 

1067 cdef DLManagedTensor* dlm_tensor 

1068 cdef const char *used_name 

1069 if cpython.PyCapsule_IsValid( 57 ctx11238VPJKLMNQRSTUWXYZ0xyw67gI5HBCDEFGAbsdehijopqrklmnfutca

1070 capsule, DLPACK_VERSIONED_TENSOR_UNUSED_NAME): 

1071 data = cpython.PyCapsule_GetPointer( 57 ctx11238VPJKLMNQRSTUWXYZ0xyw67gI5HBCDEFGAbsdehijopqrklmnfutca

1072 capsule, DLPACK_VERSIONED_TENSOR_UNUSED_NAME) 

1073 dlm_tensor_ver = <DLManagedTensorVersioned*>data 57 ctx11238VPJKLMNQRSTUWXYZ0xyw67gI5HBCDEFGAbsdehijopqrklmnfutca

1074 dl_tensor = &dlm_tensor_ver.dl_tensor 57 ctx11238VPJKLMNQRSTUWXYZ0xyw67gI5HBCDEFGAbsdehijopqrklmnfutca

1075 is_readonly = bool((dlm_tensor_ver.flags & DLPACK_FLAG_BITMASK_READ_ONLY) != 0) 57 ctx11238VPJKLMNQRSTUWXYZ0xyw67gI5HBCDEFGAbsdehijopqrklmnfutca

1076 used_name = DLPACK_VERSIONED_TENSOR_USED_NAME 57 ctx11238VPJKLMNQRSTUWXYZ0xyw67gI5HBCDEFGAbsdehijopqrklmnfutca

1077 elif cpython.PyCapsule_IsValid( 1 ctx1a

1078 capsule, DLPACK_TENSOR_UNUSED_NAME): 

1079 data = cpython.PyCapsule_GetPointer( 1 ctx1a

1080 capsule, DLPACK_TENSOR_UNUSED_NAME) 

1081 dlm_tensor = <DLManagedTensor*>data 1 ctx1a

1082 dl_tensor = &dlm_tensor.dl_tensor 1 ctx1a

1083 is_readonly = False 1 ctx1a

1084 used_name = DLPACK_TENSOR_USED_NAME 1 ctx1a

1085 else: 

1086 assert False 

1087  

1088 cpython.PyCapsule_SetName(capsule, used_name) 57 ctx11238VPJKLMNQRSTUWXYZ0xyw67gI5HBCDEFGAbsdehijopqrklmnfutca

1089  

1090 cdef StridedMemoryView buf = StridedMemoryView() if view is None else view 57 ctx11238VPJKLMNQRSTUWXYZ0xyw67gI5HBCDEFGAbsdehijopqrklmnfutca

1091 buf.dl_tensor = dl_tensor 57 ctx11238VPJKLMNQRSTUWXYZ0xyw67gI5HBCDEFGAbsdehijopqrklmnfutca

1092 buf.metadata = capsule 57 ctx11238VPJKLMNQRSTUWXYZ0xyw67gI5HBCDEFGAbsdehijopqrklmnfutca

1093 buf.ptr = <intptr_t>(dl_tensor.data) 57 ctx11238VPJKLMNQRSTUWXYZ0xyw67gI5HBCDEFGAbsdehijopqrklmnfutca

1094 buf.device_id = device_id 57 ctx11238VPJKLMNQRSTUWXYZ0xyw67gI5HBCDEFGAbsdehijopqrklmnfutca

1095 buf.is_device_accessible = is_device_accessible 57 ctx11238VPJKLMNQRSTUWXYZ0xyw67gI5HBCDEFGAbsdehijopqrklmnfutca

1096 buf.readonly = is_readonly 57 ctx11238VPJKLMNQRSTUWXYZ0xyw67gI5HBCDEFGAbsdehijopqrklmnfutca

1097 buf.exporting_obj = obj 57 ctx11238VPJKLMNQRSTUWXYZ0xyw67gI5HBCDEFGAbsdehijopqrklmnfutca

1098  

1099 return buf 57 ctx11238VPJKLMNQRSTUWXYZ0xyw67gI5HBCDEFGAbsdehijopqrklmnfutca

1100  

1101  

1102@functools.lru_cache (empty)

1103def _typestr2dtype(str typestr) -> numpy.dtype: 

1104 return numpy.dtype(typestr) 11 ctx1!#$%'()*+,4

1105  

1106  

1107@functools.lru_cache (empty)

1108def _typestr2itemsize(str typestr) -> int: 

1109 return _typestr2dtype(typestr).itemsize 11 ctx1!#$%'()*+,4

1110  

1111  

1112cdef object dtype_dlpack_to_numpy(DLDataType* dtype): (empty)

1113 cdef int bits = dtype.bits 29 ctx1gIBCDEFGAbsdehijopqrklmnfutca

1114 if dtype.lanes != 1: 29 ctx1gIBCDEFGAbsdehijopqrklmnfutca

1115 # TODO: return a NumPy structured dtype? 

1116 raise NotImplementedError( 

1117 f'vector dtypes (lanes={dtype.lanes}) is not supported') 

1118 if dtype.code == kDLUInt: 29 ctx1gIBCDEFGAbsdehijopqrklmnfutca

1119 if bits == 8: 4 ctx1klmn

1120 np_dtype = numpy.uint8 1 ctx1k