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

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) 86 ctx24 5 Y ! X R L M N O P S T U V W x z A y $ % : ' ; ( = ) * + , ? @ [ ] ^ _ ` - { | } ~ . Mb/ Kbab8 9 i K 6 J 7 D E F G H I C c u e f j k l q r s t m n o p g w v d Nbb h a Ob

78 cdef object cached = _torch_type_cache.get(tp) 86 ctx24 5 Y ! X R L M N O P S T U V W x z A y $ % : ' ; ( = ) * + , ? @ [ ] ^ _ ` - { | } ~ . Mb/ Kbab8 9 i K 6 J 7 D E F G H I C c u e f j k l q r s t m n o p g w v d Nbb h a Ob

79 if cached is not None: 86 ctx24 5 Y ! X R L M N O P S T U V W x z A y $ % : ' ; ( = ) * + , ? @ [ ] ^ _ ` - { | } ~ . Mb/ Kbab8 9 i K 6 J 7 D E F G H I C c u e f j k l q r s t m n o p g w v d Nbb h a Ob

80 return <bint>cached 77 ctx2! X R L M N O P S T U V W z A y $ % : ' ; ( = ) * + , ? @ [ ] ^ _ ` - { | } ~ . Mb8 9 i K 6 J D E F G H I C c u e f j k l q r s t m n o p g w v d Nbb h a

81 cdef str mod = tp.__module__ or "" 12 ctx24 5 Y x / Kbab7 b h a Ob

82 cdef bint result = mod.startswith("torch") and hasattr(obj, "data_ptr") \ 12 ctx24 5 Y x / Kbab7 b h a Ob

83 and _torch_version_check() 

84 _torch_type_cache[tp] = result # setdefault not needed for bools 12 ctx24 5 Y x / Kbab7 b h a Ob

85 return result 12 ctx24 5 Y x / Kbab7 b h a Ob

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 ctx2Z 0 1 2 3 Qbbb

185 if obj is not None: 8 ctx2B Z 0 1 2 3 Qbbb

186 # populate self's attributes 

187 if check_has_dlpack(obj): 6 ctx2Z 0 1 2 3 bb

188 warnings.warn( 5 ctx1Z0123

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

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

191 DeprecationWarning, 5 ctx1Z0123

192 stacklevel=2, 

193 ) 

194 view_as_dlpack(obj, stream_ptr, self) 6 ctx1BZ0123

195 else: 

196 warnings.warn( 1 ctx2bb

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

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

199 DeprecationWarning, 1 ctx2bb

200 stacklevel=2, 

201 ) 

202 view_as_cai(obj, stream_ptr, self) 1 ctx2bb

203 else: 

204 warnings.warn( 1 ctx2Qb

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

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 ctx2Qb

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) 56 ctx24 5 Y ! X R L M N O P S T U V W z A y 8 9 i K 6 J D E F G H I C c u e f j k l q r s t m n o p g w v d Nbb h a Ob

225 if _is_torch_tensor(obj): 56 ctx24 5 Y ! X R L M N O P S T U V W z A y 8 9 i K 6 J D E F G H I C c u e f j k l q r s t m n o p g w v d Nbb h a Ob

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

227 return buf 

228 view_as_dlpack(obj, stream_ptr, buf) 56 ctx24 5 Y ! X R L M N O P S T U V W z A y 8 9 i K 6 J D E F G H I C c u e f j k l q r s t m n o p g w v d Nbb h a Ob

229 return buf 54 ctx145Y!XRLMNOPSTUVWzAy89iK6JDEFGHICcuefjklqrstmnopgwvdbha

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 ctx2x / Kbab7

243 if _is_torch_tensor(obj): 5 ctx2x / Kbab7

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

245 return buf 

246 view_as_cai(obj, stream_ptr, buf) 6 ctx2B x / Kbab7

247 return buf 4 ctx2x / ab7

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 ctx2B $ % : ' ; ( = ) * + , ? @ [ ] ^ _ ` - { | } ~ . Mb

259 if _is_torch_tensor(obj): 25 ctx2$ % : ' ; ( = ) * + , ? @ [ ] ^ _ ` - { | } ~ . Mb

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

261 return buf 

262 view_as_array_interface(obj, buf) 25 ctx2$ % : ' ; ( = ) * + , ? @ [ ] ^ _ ` - { | } ~ . Mb

263 return buf 25 ctx1B$%:';(=)*+,?@[]^_`-{|}~.

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): 44 ctx24 5 Y ! X R S T U V W 1bz A y 8 9 i K 6 J C c u e f j k l q r s t m n o p g w v d b h a

283 return cls.from_dlpack(obj, stream_ptr) 43 ctx145Y!XRSTUVWzAy89iK6JCcuefjklqrstmnopgwvdbha

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

324 if itemsize is None and dtype is None: 43 ctx2TbUbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbIbJbRbWbSbcbdbPbLbQ #

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

326 if itemsize is not None and dtype is not None and itemsize != dtype.itemsize: 42 ctx2TbUbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbIbJbRbSbcbdbPbLbQ #

327 raise ValueError( 1 ctx2Sb

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

329 ) 

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

331 view_buffer_strided( 39 ctx2ebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbIbJbRbcbdbPbLbQ #

332 view, 

333 buffer, 

334 _StridedLayout(shape=shape, strides=strides, itemsize=getattr(dtype, "itemsize", itemsize)), 41 ctx2TbUbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbIbJbRbcbdbPbLbQ #

335 dtype, 

336 is_readonly, 

337 ) 

338 return view 38 ctx2B ebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbIbJbcbdbLbQ #

339  

340 def __dealloc__(self) -> None: 

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

342 return 88 ctx2TbUbx z A y $ % : ' ; ( = ) * + , ? @ [ ] ^ _ ` - { | } ~ . MbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbIbJbRbWbSbcbdbPbLb/ KbabQ Qbbb# 6 J 7 D E F G H I NbOb

343  

344 if cpython.PyCapsule_IsValid( 58 ctx145Y!XRLMNOPSTUVWZ0123zAy89iK6JDEFGHICuefjklqrstmnopgwvdbha

345 self.metadata, DLPACK_VERSIONED_TENSOR_USED_NAME): 58 ctx145Y!XRLMNOPSTUVWZ0123zAy89iK6JDEFGHICuefjklqrstmnopgwvdbha

346 data = cpython.PyCapsule_GetPointer( 57 ctx145Y!XRLMNOPSTUVWZ0123zAy89iK6JDEFGHICuefjklqrstmnopgwvdha

347 self.metadata, DLPACK_VERSIONED_TENSOR_USED_NAME) 57 ctx145Y!XRLMNOPSTUVWZ0123zAy89iK6JDEFGHICuefjklqrstmnopgwvdha

348 dlm_tensor_ver = <DLManagedTensorVersioned*>data 57 ctx145Y!XRLMNOPSTUVWZ0123zAy89iK6JDEFGHICuefjklqrstmnopgwvdha

349 if dlm_tensor_ver.deleter != NULL: 57 ctx145Y!XRLMNOPSTUVWZ0123zAy89iK6JDEFGHICuefjklqrstmnopgwvdha

350 dlm_tensor_ver.deleter(dlm_tensor_ver) 56 ctx145Y!XRLMNOPSTUVWZ0123zAy89iK6JDEFGHICuefjklqrstmnopgwvda

351 elif cpython.PyCapsule_IsValid( 3 ctx1Bba

352 self.metadata, DLPACK_TENSOR_USED_NAME): 2 ctx1ba

353 data = cpython.PyCapsule_GetPointer( 2 ctx1ba

354 self.metadata, DLPACK_TENSOR_USED_NAME) 2 ctx1ba

355 dlm_tensor = <DLManagedTensor*>data 2 ctx1ba

356 if dlm_tensor.deleter != NULL: 2 ctx1ba

357 dlm_tensor.deleter(dlm_tensor) 1 ctx1a

358  

359 def view( (empty)

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

361 ) -> StridedMemoryView: 

362 """ 

363 Creates a new view with adjusted layout and dtype. 

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

365 """ 

366 cdef StridedMemoryView view = StridedMemoryView.__new__(self.__class__) 13 ctx2z A y cbdb6 J D E F G H I

367 if layout is None and dtype is None: 13 ctx2z A y cbdb6 J D E F G H I

368 return self 1 ctx16

369 if layout is None: 12 ctx2z A y cbdbJ D E F G H I

370 layout = self.get_layout() 5 ctx1BzAyJ

371 if dtype is None: 12 ctx2z A y cbdbJ D E F G H I

372 dtype = self.get_dtype() 8 ctx2cbdbD E F G H I

373 view_buffer_strided(view, self.get_buffer(), layout, dtype, self.readonly) 12 ctx2z A y cbdbJ D E F G H I

374 return view 12 ctx2z A y cbdbJ D E F G H I

375  

376 def as_tensor_map( (empty)

377 self, 

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

379 *, 

380 options: object = None, (empty)

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

382 data_type: object = None, (empty)

383 interleave: object = None, (empty)

384 swizzle: object = None, (empty)

385 l2_promotion: object = None, (empty)

386 oob_fill: object = None, (empty)

387 ) -> object: 

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

389  

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

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

392 individual keyword arguments directly, or provide bundled tiled 

393 options via ``options=``. 

394 """ 

395 from cuda.core._tensor_map import TensorMapDescriptor 1 ctx1R

396  

397 kwargs = {} 1 ctx1R

398 if options is not None: 1 ctx1R

399 kwargs["options"] = options 

400 if element_strides is not None: 1 ctx1R

401 kwargs["element_strides"] = element_strides 2 ctx1BR

402 if data_type is not None: 1 ctx1R

403 kwargs["data_type"] = data_type 1 ctx1R

404 if interleave is not None: 1 ctx1R

405 kwargs["interleave"] = interleave 

406 if swizzle is not None: 1 ctx1R

407 kwargs["swizzle"] = swizzle 1 ctx1R

408 if l2_promotion is not None: 1 ctx1R

409 kwargs["l2_promotion"] = l2_promotion 1 ctx1R

410 if oob_fill is not None: 1 ctx1R

411 kwargs["oob_fill"] = oob_fill 1 ctx1R

412 return TensorMapDescriptor._from_tiled(self, box_dim, **kwargs) 1 ctx1R

413  

414 def copy_from( (empty)

415 self, 

416 other: StridedMemoryView, 

417 stream: Stream, 

418 allocator: object = None, 

419 blocking: bool | None = None, 

420 ) -> None: 

421 """ 

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

423  

424 The copy can be performed between following memory spaces: 

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

426  

427 Parameters 

428 ---------- 

429 other : StridedMemoryView 

430 The view to copy data from. 

431 stream : Stream | None, optional 

432 The stream to schedule the copy on. 

433 allocator : MemoryResource | None, optional 

434 If temporary buffers are needed, the specified memory resources 

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

436 resources will be used. 

437 blocking : bool | None, optional 

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

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

440 blocking until the copy is complete. 

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

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

443 still synchronize with the host if necessary. 

444 * ``None`` (default): 

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

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

447 """ 

448 raise NotImplementedError("Sorry, not supported: copy_from") 1 ctx18

449  

450 def copy_to( (empty)

451 self, 

452 other: StridedMemoryView, 

453 stream: Stream | None = None, 

454 allocator: object = None, 

455 blocking: bool | None = None, 

456 ) -> None: 

457 """ 

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

459  

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

461 """ 

462 raise NotImplementedError("Sorry, not supported: copy_to") 1 ctx19

463  

464 def __dlpack__( (empty)

465 self, 

466 *, 

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

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

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

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

471 ) -> object: 

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

473 if dl_device is not None: 28 ctx1YxzAyiQuefjklqrstmnopgwvdbha

474 raise BufferError("Sorry, not supported: dl_device other than None") 1 ctx1Y

475 if copy is True: 28 ctx1YxzAyiQuefjklqrstmnopgwvdbha

476 raise BufferError("Sorry, not supported: copy=True") 1 ctx1Y

477  

478 cdef bint versioned 

479 if max_version is None: 28 ctx1YxzAyiQuefjklqrstmnopgwvdbha

480 versioned = False 8 ctx1xzAyQvba

481 else: 

482 if not isinstance(max_version, tuple) or len(max_version) != 2: 21 ctx1Yiuefjklqrstmnopgwdha

483 raise BufferError(f"Expected max_version tuple[int, int], got {max_version}") 1 ctx1Y

484 versioned = max_version >= (1, 0) 20 ctx1iuefjklqrstmnopgwdha

485  

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

487 cdef object capsule = _smv_make_py_capsule(self, versioned) 27 ctx1xzAyiQuefjklqrstmnopgwvdbha

488 return capsule 23 ctx1xiuefjklqrstmnopgwvdbha

489  

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

491 cdef _DLDeviceType device_type 

492 cdef int32_t device_id 

493 _smv_get_dl_device(self, &device_type, &device_id) 7 ctx145xibha

494 return (<int>device_type, int(device_id)) 7 ctx145xibha

495  

496 @property 

497 def _layout(self) -> _StridedLayout: 

498 """ 

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

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

501 """ 

502 return self.get_layout() 42 ctx2ebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbIbJbcbdbQbJ D E F G H I

503  

504 @property 

505 def size(self) -> int: 

506 return self.get_layout().get_volume() 40 ctx1LMNOPSTUVWZ0123$%:';(=)*+,?@[]^_`-{|}~./

507  

508 @property 

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

510 """ 

511 Shape of the tensor. 

512 """ 

513 return self.get_layout().get_shape_tuple() 87 ctx2X L M N O P S T U V W Z 0 1 2 3 $ % : ' ; ( = ) * + , ? @ [ ] ^ _ ` - { | } ~ . ebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbIbJbcbdb/ abbb# K 7 D E F G H I c

514  

515 @property 

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

517 """ 

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

519 """ 

520 return self.get_layout().get_strides_tuple() 76 ctx2X L M N O P S T U V W Z 0 1 2 3 $ % : ' ; ( = ) * + , ? @ [ ] ^ _ ` - { | } ~ . ebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbIbJb/ ab# K

521  

522 @property 

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

524 """ 

525 Data type of the tensor. 

526  

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

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

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

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

531 """ 

532 return self.get_dtype() 66 ctx2$ % : ' ; ( = ) * + , ? @ [ ] ^ _ ` - { | } ~ . ebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbIbJbLb# K J D E F G H I

533  

534 def __repr__(self) -> str: 

535 return (f"StridedMemoryView(ptr={self.ptr},\n" 2 ctx1#K

536 + f" shape={self.shape},\n" 2 ctx1#K

537 + f" strides={self.strides},\n" 2 ctx1#K

538 + f" itemsize={self._layout.itemsize},\n" 2 ctx1#K

539 + f" dtype={get_simple_repr(self.dtype)},\n" 2 ctx1#K

540 + f" device_id={self.device_id},\n" 2 ctx1#K

541 + f" is_device_accessible={self.is_device_accessible},\n" 3 ctx1B#K

542 + f" readonly={self.readonly},\n" 2 ctx1#K

543 + f" exporting_obj={get_simple_repr(self.exporting_obj)})") 2 ctx1#K

544  

545 @cython.critical_section (empty)

546 cdef inline _StridedLayout get_layout(self): 

547 if self._layout is None: 119 ctx2X L M N O P S T U V W Z 0 1 2 3 x z A y $ % : ' ; ( = ) * + , ? @ [ ] ^ _ ` - { | } ~ . MbebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbIbJbcbdb/ Kbabi Q Qbbb# K J 7 D E F G H I C c u e f j k l q r s t m n o p g w v d b h a

548 if self.dl_tensor: 84 ctx2B X L M N O P S T U V W Z 0 1 2 3 x z A y $ % : ' ; ( = ) * + , ? @ [ ] ^ _ ` - { | } ~ . Mb/ Kbabi QbbbK J 7 D E F G H I C c u e f j k l q r s t m n o p g w v d b h a

549 self._layout = layout_from_dlpack(self.dl_tensor) 51 ctx1XLMNOPSTUVWZ0123zAyiKJDEFGHICcuefjklqrstmnopgwvdbha

550 elif self.metadata is not None: 32 ctx2x $ % : ' ; ( = ) * + , ? @ [ ] ^ _ ` - { | } ~ . Mb/ KbabQbbb7

551 self._layout = layout_from_cai(self.metadata) 31 ctx2x $ % : ' ; ( = ) * + , ? @ [ ] ^ _ ` - { | } ~ . Mb/ Kbabbb7

552 else: 

553 raise ValueError("Cannot infer layout from the exporting object") 1 ctx2Qb

554 return self._layout 116 ctx2X L M N O P S T U V W Z 0 1 2 3 x z A y $ % : ' ; ( = ) * + , ? @ [ ] ^ _ ` - { | } ~ . ebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbIbJbcbdb/ abi Q bb# K J 7 D E F G H I C c u e f j k l q r s t m n o p g w v d b h a

555  

556 @cython.critical_section (empty)

557 cdef inline object get_buffer(self): 

558 """ 

559 Returns Buffer instance with the underlying data. 

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

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

562 """ 

563 if self._buffer is None: 13 ctx2x z A y cbdbJ D E F G H I

564 if isinstance(self.exporting_obj, Buffer): 11 ctx1xzAyJDEFGHI

565 self._buffer = self.exporting_obj (empty)

566 else: 

567 self._buffer = Buffer.from_handle(self.ptr, 0, owner=self.exporting_obj) 11 ctx1xzAyJDEFGHI

568 return self._buffer 13 ctx2x z A y cbdbJ D E F G H I

569  

570 @cython.critical_section (empty)

571 cdef inline object get_dtype(self): 

572 if self._dtype is None: 97 ctx2x z A y $ % : ' ; ( = ) * + , ? @ [ ] ^ _ ` - { | } ~ . ebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbIbJbcbdbLbi Q # K J D E F G H I C c u e f j k l q r s t m n o p g w v d b h a

573 if self.dl_tensor != NULL: 58 ctx1x$%:';(=)*+,?@[]^_`-{|}~.iQ#KDEFGHICcuefjklqrstmnopgwvdbha

574 self._dtype = dtype_dlpack_to_numpy(&self.dl_tensor.dtype) 31 ctx1iKDEFGHICcuefjklqrstmnopgwvdbha

575 elif isinstance(self.metadata, int): 27 ctx1x$%:';(=)*+,?@[]^_`-{|}~.Q#

576 # AOTI dtype code stored by the torch tensor bridge 

577 self._dtype = _get_tensor_bridge().resolve_aoti_dtype( 

578 self.metadata) 

579 elif self.metadata is not None: 27 ctx1x$%:';(=)*+,?@[]^_`-{|}~.Q#

580 self._dtype = _typestr2dtype(self.metadata["typestr"]) 25 ctx1x$%:';(=)*+,?@[]^_`-{|}~.

581 return self._dtype 97 ctx2x z A y $ % : ' ; ( = ) * + , ? @ [ ] ^ _ ` - { | } ~ . ebfbgbhbibjbkblbmbnbobpbqbrbsbtbubvbwbxbybzbAbBbCbDbEbFbGbHbIbJbcbdbLbi Q # K J D E F G H I C c u e f j k l q r s t m n o p g w v d b h a

582  

583  

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

585 cdef DLManagedTensor* dlm_tensor 

586 cdef DLManagedTensorVersioned* dlm_tensor_ver 

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

588 if cpython.PyCapsule_IsValid(capsule, DLPACK_TENSOR_UNUSED_NAME): 21 ctx1xiuefjklqrstmnopgwvda

589 dlm_tensor = <DLManagedTensor*>( 2 ctx1xv

590 cpython.PyCapsule_GetPointer(capsule, DLPACK_TENSOR_UNUSED_NAME) 2 ctx1xv

591 ) 

592 if dlm_tensor.deleter: 2 ctx1xv

593 dlm_tensor.deleter(dlm_tensor) 2 ctx1xv

594 elif cpython.PyCapsule_IsValid(capsule, DLPACK_VERSIONED_TENSOR_UNUSED_NAME): 19 ctx1iuefjklqrstmnopgwda

595 dlm_tensor_ver = <DLManagedTensorVersioned*>( 2 ctx1Bd

596 cpython.PyCapsule_GetPointer(capsule, DLPACK_VERSIONED_TENSOR_UNUSED_NAME) 1 ctx1d

597 ) 

598 if dlm_tensor_ver.deleter: 1 ctx1d

599 dlm_tensor_ver.deleter(dlm_tensor_ver) 1 ctx1d

600  

601  

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

603 if shape_ptr: 27 ctx1xzAyiQuefjklqrstmnopgwvdbha

604 stdlib.free(shape_ptr) 22 ctx1xiuefjklqrstmnopgvdbha

605 if manager_ctx: 27 ctx1xzAyiQuefjklqrstmnopgwvdbha

606 cpython.Py_DECREF(<object>manager_ctx) 27 ctx1xzAyiQuefjklqrstmnopgwvdbha

607  

608  

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

610 if tensor: 8 ctx1xzAyQvba

611 _smv_release_export_resources(tensor.manager_ctx, tensor.dl_tensor.shape) 8 ctx1xzAyQvba

612 tensor.manager_ctx = NULL 8 ctx1xzAyQvba

613 stdlib.free(tensor) 9 ctx1BxzAyQvba

614  

615  

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

617 if tensor: 24 ctx1zAyiQuefjklqrstmnopgwdha

618 _smv_release_export_resources(tensor.manager_ctx, tensor.dl_tensor.shape) 20 ctx1iuefjklqrstmnopgwdha

619 tensor.manager_ctx = NULL 20 ctx1iuefjklqrstmnopgwdha

620 stdlib.free(tensor) 20 ctx1iuefjklqrstmnopgwdha

621  

622  

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

624 cdef DLManagedTensorVersioned* dlm_tensor_ver = NULL 21 ctx1icuefjklqrstmnopgwdha

625 dlm_tensor_ver = <DLManagedTensorVersioned*>stdlib.malloc(sizeof(DLManagedTensorVersioned)) 21 ctx1icuefjklqrstmnopgwdha

626 if dlm_tensor_ver == NULL: 21 ctx1icuefjklqrstmnopgwdha

627 raise MemoryError() 

628 dlm_tensor_ver.dl_tensor.shape = NULL 21 ctx1icuefjklqrstmnopgwdha

629 dlm_tensor_ver.manager_ctx = NULL 21 ctx1icuefjklqrstmnopgwdha

630 return dlm_tensor_ver 21 ctx1icuefjklqrstmnopgwdha

631  

632  

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

634 cdef DLManagedTensor* dlm_tensor = NULL 8 ctx1xzAyQvba

635 dlm_tensor = <DLManagedTensor*>stdlib.malloc(sizeof(DLManagedTensor)) 8 ctx1xzAyQvba

636 if dlm_tensor == NULL: 8 ctx1xzAyQvba

637 raise MemoryError() 

638 dlm_tensor.dl_tensor.shape = NULL 8 ctx1xzAyQvba

639 dlm_tensor.manager_ctx = NULL 8 ctx1xzAyQvba

640 return dlm_tensor 9 ctx1BxzAyQvba

641  

642  

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

644 cdef object np_dtype = numpy.dtype(dtype_obj) 28 ctx1xzAyiCcuefjklqrstmnopgwvdbha

645 if np_dtype.fields is not None: 28 ctx1xzAyiCcuefjklqrstmnopgwvdbha

646 raise BufferError("Structured dtypes are not supported for DLPack export") 1 ctx1A

647 if not np_dtype.isnative and np_dtype.byteorder not in ("=", "|"): 27 ctx1xzyiCcuefjklqrstmnopgwvdbha

648 raise BufferError("Non-native-endian dtypes are not supported for DLPack export") 2 ctx1Bz

649  

650 cdef str kind = np_dtype.kind 26 ctx1xyiCcuefjklqrstmnopgwvdbha

651 cdef int bits = np_dtype.itemsize * 8 26 ctx1xyiCcuefjklqrstmnopgwvdbha

652 cdef uint8_t code 

653 if kind == "b": 26 ctx1xyiCcuefjklqrstmnopgwvdbha

654 if bits != 8: 1 ctx1u

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

656 code = <uint8_t>kDLBool 1 ctx1u

657 elif kind == "i": 25 ctx1xyiCcefjklqrstmnopgwvdbha

658 if bits not in (8, 16, 32, 64): 11 ctx1iCqrstvdbha

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

660 code = <uint8_t>kDLInt 11 ctx1iCqrstvdbha

661 elif kind == "u": 14 ctx1xycefjklmnopgw

662 if bits not in (8, 16, 32, 64): 4 ctx1mnop

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

664 code = <uint8_t>kDLUInt 4 ctx1mnop

665 elif kind == "f": 10 ctx1xycefjklgw

666 if bits not in (16, 32, 64): 5 ctx1xcjkl

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

668 code = <uint8_t>kDLFloat 6 ctx1Bxcjkl

669 elif kind == "c": 5 ctx1yefgw

670 if bits not in (64, 128): 4 ctx1efgw

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

672 code = <uint8_t>kDLComplex 4 ctx1efgw

673 else: 

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

675  

676 out_dtype.code = code 25 ctx1xiCcuefjklqrstmnopgwvdbha

677 out_dtype.bits = <uint8_t>bits 25 ctx1xiCcuefjklqrstmnopgwvdbha

678 out_dtype.lanes = <uint16_t>1 26 ctx1BxiCcuefjklqrstmnopgwvdbha

679 return 0 25 ctx1xiCcuefjklqrstmnopgwvdbha

680  

681  

682cdef inline int _smv_get_dl_device( (empty)

683 StridedMemoryView view, 

684 _DLDeviceType* out_device_type, 

685 int32_t* out_device_id, 

686) except -1: 

687 cdef _DLDeviceType device_type 

688 cdef int32_t device_id 

689 cdef object buf 

690 if view.dl_tensor != NULL: 27 ctx145xiCcuefjklqrstmnopgwvdbha

691 device_type = view.dl_tensor.device.device_type 26 ctx145iCcuefjklqrstmnopgwvdbha

692 if device_type == _kDLCUDA: 26 ctx145iCcuefjklqrstmnopgwvdbha

693 device_id = view.dl_tensor.device.device_id 

694 else: 

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

696 device_id = 0 26 ctx145iCcuefjklqrstmnopgwvdbha

697 elif view.is_device_accessible: 1 ctx1x

698 buf = view.get_buffer() 1 ctx1x

699 dev_type, dev_id = classify_dl_device(buf) 1 ctx1x

700 device_type = <_DLDeviceType>dev_type 1 ctx1x

701 device_id = <int32_t>dev_id 1 ctx1x

702 else: 

703 device_type = _kDLCPU 

704 device_id = 0 

705  

706 out_device_type[0] = device_type 27 ctx145xiCcuefjklqrstmnopgwvdbha

707 out_device_id[0] = device_id 27 ctx145xiCcuefjklqrstmnopgwvdbha

708 return 0 27 ctx145xiCcuefjklqrstmnopgwvdbha

709  

710  

711cdef inline int _smv_setup_dl_tensor_common( (empty)

712 DLTensor* dl_tensor, 

713 StridedMemoryView view, 

714 _StridedLayout layout, 

715) except -1: 

716 cdef object dtype_obj = view.get_dtype() 29 ctx1xzAyiQCcuefjklqrstmnopgwvdbha

717 if dtype_obj is None: 29 ctx1xzAyiQCcuefjklqrstmnopgwvdbha

718 raise BufferError( 1 ctx1Q

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

720 "create the view with dtype specified." 

721 ) 

722 _smv_dtype_numpy_to_dlpack(dtype_obj, &dl_tensor.dtype) 28 ctx1xzAyiCcuefjklqrstmnopgwvdbha

723 _smv_get_dl_device(view, &dl_tensor.device.device_type, &dl_tensor.device.device_id) 25 ctx1xiCcuefjklqrstmnopgwvdbha

724  

725 cdef int ndim = layout.base.ndim 25 ctx1xiCcuefjklqrstmnopgwvdbha

726 dl_tensor.ndim = ndim 25 ctx1xiCcuefjklqrstmnopgwvdbha

727 if layout.get_volume() == 0: 25 ctx1xiCcuefjklqrstmnopgwvdbha

728 dl_tensor.data = NULL 1 ctx1g

729 else: 

730 dl_tensor.data = <void*><intptr_t>view.ptr 24 ctx1xiCcuefjklqrstmnopwvdbha

731 dl_tensor.byte_offset = 0 25 ctx1xiCcuefjklqrstmnopgwvdbha

732 return 0 25 ctx1xiCcuefjklqrstmnopgwvdbha

733  

734  

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

736 cdef _StridedLayout layout = view.get_layout() 28 ctx1xzAyiQcuefjklqrstmnopgwvdbha

737 _smv_setup_dl_tensor_common(dl_tensor, view, layout) 28 ctx1xzAyiQcuefjklqrstmnopgwvdbha

738  

739 cdef int i 

740 cdef int64_t* shape_strides = NULL 24 ctx1xicuefjklqrstmnopgwvdbha

741 cdef int64_t* strides_src = NULL 24 ctx1xicuefjklqrstmnopgwvdbha

742 cdef int ndim = dl_tensor.ndim 24 ctx1xicuefjklqrstmnopgwvdbha

743 if ndim == 0: 24 ctx1xicuefjklqrstmnopgwvdbha

744 dl_tensor.shape = NULL 1 ctx1w

745 dl_tensor.strides = NULL 1 ctx1w

746 else: 

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

748 shape_strides = <int64_t*>stdlib.malloc(sizeof(int64_t) * 2 * ndim) 23 ctx1xicuefjklqrstmnopgvdbha

749 if shape_strides == NULL: 23 ctx1xicuefjklqrstmnopgvdbha

750 raise MemoryError() 

751 try: 23 ctx1xicuefjklqrstmnopgvdbha

752 strides_src = get_strides_ptr(layout.base) 23 ctx1xicuefjklqrstmnopgvdbha

753 for i in range(ndim): 23 ctx1xicuefjklqrstmnopgvdbha

754 shape_strides[i] = layout.base.shape[i] 23 ctx1xicuefjklqrstmnopgvdbha

755 shape_strides[i + ndim] = strides_src[i] 23 ctx1xicuefjklqrstmnopgvdbha

756 except Exception: 

757 stdlib.free(shape_strides) 

758 raise 

759 dl_tensor.shape = shape_strides 23 ctx1xicuefjklqrstmnopgvdbha

760 dl_tensor.strides = shape_strides + ndim 23 ctx1xicuefjklqrstmnopgvdbha

761 return 0 24 ctx1xicuefjklqrstmnopgwvdbha

762  

763  

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

765 cdef _StridedLayout layout = view.get_layout() 1 ctx1C

766 _smv_setup_dl_tensor_common(dl_tensor, view, layout) 1 ctx1C

767  

768 if dl_tensor.ndim == 0: 1 ctx1C

769 dl_tensor.shape = NULL 

770 dl_tensor.strides = NULL 

771 else: 

772 dl_tensor.shape = layout.base.shape 1 ctx1C

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

774 dl_tensor.strides = get_strides_ptr(layout.base) 1 ctx1C

775 return 0 1 ctx1C

776  

777  

778cdef inline int _smv_fill_managed_tensor_versioned( (empty)

779 DLManagedTensorVersioned* dlm_tensor_ver, 

780 StridedMemoryView view, 

781) except -1: 

782 cpython.Py_INCREF(view) 21 ctx1icuefjklqrstmnopgwdha

783 dlm_tensor_ver.manager_ctx = <void*>view 21 ctx1icuefjklqrstmnopgwdha

784 dlm_tensor_ver.deleter = _smv_versioned_deleter 21 ctx1icuefjklqrstmnopgwdha

785 dlm_tensor_ver.version.major = DLPACK_MAJOR_VERSION 21 ctx1icuefjklqrstmnopgwdha

786 dlm_tensor_ver.version.minor = DLPACK_MINOR_VERSION 21 ctx1icuefjklqrstmnopgwdha

787 dlm_tensor_ver.flags = DLPACK_FLAG_BITMASK_READ_ONLY if view.readonly else 0 21 ctx1icuefjklqrstmnopgwdha

788 _smv_setup_dl_tensor(&dlm_tensor_ver.dl_tensor, view) 21 ctx1icuefjklqrstmnopgwdha

789 return 0 21 ctx1icuefjklqrstmnopgwdha

790  

791  

792cdef inline int _smv_fill_managed_tensor( (empty)

793 DLManagedTensor* dlm_tensor, 

794 StridedMemoryView view, 

795) except -1: 

796 cpython.Py_INCREF(view) 8 ctx1xzAyQvba

797 dlm_tensor.manager_ctx = <void*>view 8 ctx1xzAyQvba

798 dlm_tensor.deleter = _smv_deleter 8 ctx1xzAyQvba

799 _smv_setup_dl_tensor(&dlm_tensor.dl_tensor, view) 8 ctx1xzAyQvba

800 return 0 4 ctx1xvba

801  

802  

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

804 cdef DLManagedTensor* dlm_tensor = NULL 27 ctx1xzAyiQuefjklqrstmnopgwvdbha

805 cdef DLManagedTensorVersioned* dlm_tensor_ver = NULL 27 ctx1xzAyiQuefjklqrstmnopgwvdbha

806 cdef object capsule = None 27 ctx1xzAyiQuefjklqrstmnopgwvdbha

807 cdef void* tensor_ptr = NULL 27 ctx1xzAyiQuefjklqrstmnopgwvdbha

808 cdef const char* capsule_name 

809 try: 27 ctx1xzAyiQuefjklqrstmnopgwvdbha

810 if versioned: 27 ctx1xzAyiQuefjklqrstmnopgwvdbha

811 dlm_tensor_ver = _smv_allocate_dlm_tensor_versioned() 20 ctx1iuefjklqrstmnopgwdha

812 _smv_fill_managed_tensor_versioned(dlm_tensor_ver, view) 20 ctx1iuefjklqrstmnopgwdha

813 tensor_ptr = <void*>dlm_tensor_ver 20 ctx1iuefjklqrstmnopgwdha

814 capsule_name = DLPACK_VERSIONED_TENSOR_UNUSED_NAME 20 ctx1iuefjklqrstmnopgwdha

815 else: 

816 dlm_tensor = _smv_allocate_dlm_tensor() 8 ctx1xzAyQvba

817 _smv_fill_managed_tensor(dlm_tensor, view) 8 ctx1xzAyQvba

818 tensor_ptr = <void*>dlm_tensor 4 ctx1xvba

819 capsule_name = DLPACK_TENSOR_UNUSED_NAME 4 ctx1xvba

820 capsule = cpython.PyCapsule_New(tensor_ptr, capsule_name, _smv_pycapsule_deleter) 23 ctx1xiuefjklqrstmnopgwvdbha

821 except Exception: 4 ctx1zAyQ

822 if capsule is None: 4 ctx1zAyQ

823 _smv_deleter(dlm_tensor) 4 ctx1zAyQ

824 _smv_versioned_deleter(dlm_tensor_ver) 4 ctx1zAyQ

825 raise 4 ctx1zAyQ

826 return capsule 23 ctx1xiuefjklqrstmnopgwvdbha

827  

828  

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

830 cdef void* data = NULL 1 ctx1c

831 cdef DLTensor* dl_tensor = NULL 1 ctx1c

832 cdef DLManagedTensorVersioned* dlm_tensor_ver = NULL 1 ctx1c

833 cdef DLManagedTensor* dlm_tensor = NULL 1 ctx1c

834 cdef bint is_readonly = False 1 ctx1c

835 cdef const char* used_name = NULL 1 ctx1c

836 if cpython.PyCapsule_IsValid(capsule, DLPACK_VERSIONED_TENSOR_UNUSED_NAME): 1 ctx1c

837 data = cpython.PyCapsule_GetPointer(capsule, DLPACK_VERSIONED_TENSOR_UNUSED_NAME) 1 ctx1c

838 dlm_tensor_ver = <DLManagedTensorVersioned*>data 1 ctx1c

839 dl_tensor = &dlm_tensor_ver.dl_tensor 1 ctx1c

840 is_readonly = bool((dlm_tensor_ver.flags & DLPACK_FLAG_BITMASK_READ_ONLY) != 0) 1 ctx1c

841 used_name = DLPACK_VERSIONED_TENSOR_USED_NAME 1 ctx1c

842 elif cpython.PyCapsule_IsValid(capsule, DLPACK_TENSOR_UNUSED_NAME): 

843 data = cpython.PyCapsule_GetPointer(capsule, DLPACK_TENSOR_UNUSED_NAME) 

844 dlm_tensor = <DLManagedTensor*>data 

845 dl_tensor = &dlm_tensor.dl_tensor 

846 is_readonly = False 

847 used_name = DLPACK_TENSOR_USED_NAME 

848 else: 

849 raise BufferError("Invalid DLPack capsule") 

850  

851 cpython.PyCapsule_SetName(capsule, used_name) 1 ctx1c

852  

853 cdef StridedMemoryView view = StridedMemoryView.__new__(StridedMemoryView) 1 ctx1c

854 view.dl_tensor = dl_tensor 1 ctx1c

855 view.metadata = capsule 1 ctx1c

856 view.ptr = <intptr_t>(dl_tensor.data) + <intptr_t>(dl_tensor.byte_offset) 1 ctx1c

857 view.readonly = is_readonly 1 ctx1c

858 view.exporting_obj = exporting_obj 1 ctx1c

859 if dl_tensor.device.device_type == _kDLCPU: 1 ctx1c

860 view.device_id = -1 1 ctx1c

861 view.is_device_accessible = False 1 ctx1c

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

863 view.device_id = dl_tensor.device.device_id 

864 view.is_device_accessible = True 

865 else: 

866 raise BufferError("device not supported") 

867 return view 1 ctx1c

868  

869  

870cdef int _smv_managed_tensor_allocator( (empty)

871 DLTensor* prototype, 

872 DLManagedTensorVersioned** out, 

873 void* error_ctx, 

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

875) noexcept with gil: 

876 if out != NULL: 1 ctx2Xb

877 out[0] = NULL 1 ctx2Xb

878 if SetError != NULL: 1 ctx2Xb

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

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

881 return -1 1 ctx2Xb

882  

883  

884cdef int _smv_managed_tensor_from_py_object_no_sync( (empty)

885 void* py_object, 

886 DLManagedTensorVersioned** out, 

887) noexcept with gil: 

888 cdef DLManagedTensorVersioned* dlm_tensor_ver = NULL 1 ctx1c

889 if out == NULL: 1 ctx1c

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

891 return -1 

892 out[0] = NULL 1 ctx1c

893 cdef object obj = <object>py_object 1 ctx1c

894 if not isinstance(obj, StridedMemoryView): 1 ctx1c

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

896 return -1 

897 try: 1 ctx1c

898 dlm_tensor_ver = _smv_allocate_dlm_tensor_versioned() 1 ctx1c

899 _smv_fill_managed_tensor_versioned(dlm_tensor_ver, <StridedMemoryView>obj) 1 ctx1c

900 except Exception: 

901 _smv_versioned_deleter(dlm_tensor_ver) 

902 return -1 

903 out[0] = dlm_tensor_ver 1 ctx1c

904 return 0 1 ctx1c

905  

906  

907cdef int _smv_managed_tensor_to_py_object_no_sync( (empty)

908 DLManagedTensorVersioned* tensor, 

909 void** out_py_object, 

910) noexcept with gil: 

911 cdef object capsule 

912 cdef object py_view 

913 if out_py_object == NULL: 2 ctx2c Yb

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

915 return -1 

916 out_py_object[0] = NULL 2 ctx2c Yb

917 if tensor == NULL: 2 ctx2c Yb

918 cpython.PyErr_SetString(RuntimeError, b"tensor cannot be NULL") 1 ctx2Yb

919 return -1 1 ctx2Yb

920 try: 1 ctx1c

921 capsule = cpython.PyCapsule_New( 1 ctx1c

922 <void*>tensor, 

923 DLPACK_VERSIONED_TENSOR_UNUSED_NAME, 

924 _smv_pycapsule_deleter, 

925 ) 

926 py_view = _smv_from_dlpack_capsule(capsule, capsule) 1 ctx1c

927 cpython.Py_INCREF(py_view) 1 ctx1c

928 out_py_object[0] = <void*>py_view 1 ctx1c

929 except Exception: 

930 return -1 

931 return 0 1 ctx1c

932  

933  

934cdef int _smv_dltensor_from_py_object_no_sync( (empty)

935 void* py_object, 

936 DLTensor* out, 

937) noexcept with gil: 

938 if out == NULL: 2 ctx2ZbC

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

940 return -1 

941 cdef object obj = <object>py_object 2 ctx2ZbC

942 if not isinstance(obj, StridedMemoryView): 2 ctx2ZbC

943 cpython.PyErr_SetString(TypeError, b"py_object must be a StridedMemoryView") 1 ctx2Zb

944 return -1 1 ctx2Zb

945 try: 1 ctx1C

946 _smv_setup_dltensor_borrowed(out, <StridedMemoryView>obj) 1 ctx1C

947 except Exception: 

948 return -1 

949 return 0 1 ctx1C

950  

951  

952cdef int _smv_current_work_stream( (empty)

953 _DLDeviceType device_type, 

954 int32_t device_id, 

955 void** out_current_stream, 

956) noexcept with gil: 

957 if out_current_stream == NULL: 1 ctx24b

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

959 return -1 

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

961 out_current_stream[0] = NULL 1 ctx24b

962 return 0 1 ctx24b

963  

964  

965cdef void _init_smv_dlpack_exchange_api(): (empty)

966 global _SMV_DLPACK_EXCHANGE_API_INITED 

967 if _SMV_DLPACK_EXCHANGE_API_INITED: (empty)

968 return 

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

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

971 _SMV_DLPACK_EXCHANGE_API.header.prev_api = NULL (empty)

972 _SMV_DLPACK_EXCHANGE_API.managed_tensor_allocator = _smv_managed_tensor_allocator (empty)

973 _SMV_DLPACK_EXCHANGE_API.managed_tensor_from_py_object_no_sync = _smv_managed_tensor_from_py_object_no_sync (empty)

974 _SMV_DLPACK_EXCHANGE_API.managed_tensor_to_py_object_no_sync = _smv_managed_tensor_to_py_object_no_sync (empty)

975 _SMV_DLPACK_EXCHANGE_API.dltensor_from_py_object_no_sync = _smv_dltensor_from_py_object_no_sync (empty)

976 _SMV_DLPACK_EXCHANGE_API.current_work_stream = _smv_current_work_stream (empty)

977 _SMV_DLPACK_EXCHANGE_API_INITED = True (empty)

978  

979  

980_init_smv_dlpack_exchange_api() (empty)

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

982# directly into the type dict. 

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

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

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

986  

987  

988cdef str get_simple_repr(obj): (empty)

989 # TODO: better handling in np.dtype objects 

990 cdef object obj_class 

991 cdef str obj_repr 

992 if isinstance(obj, type): 2 ctx1#K

993 obj_class = obj 

994 else: 

995 obj_class = obj.__class__ 2 ctx1#K

996 if obj_class.__module__ in (None, "builtins"): 2 ctx1#K

997 obj_repr = obj_class.__name__ 1 ctx1#

998 else: 

999 obj_repr = f"{obj_class.__module__}.{obj_class.__name__}" 2 ctx1#K

1000 return obj_repr 2 ctx1#K

1001  

1002  

1003  

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

1005 cdef bint has_dlpack 

1006 if hasattr(obj, "__dlpack__") and hasattr(obj, "__dlpack_device__"): 56 ctx24 5 Y ! X R L M N O P S T U V W Z 0 1 2 3 1bz A y 8 9 i bbVbK 6 J C c u e f j k l q r s t m n o p g w v d b h a

1007 has_dlpack = True 53 ctx145Y!XRLMNOPSTUVWZ0123zAy89iK6JCcuefjklqrstmnopgwvdbha

1008 elif hasattr(obj, "__cuda_array_interface__"): 3 ctx21bbbVb

1009 has_dlpack = False 2 ctx2bbVb

1010 else: 

1011 raise BufferError( 1 ctx21b

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

1013 return has_dlpack 55 ctx24 5 Y ! X R L M N O P S T U V W Z 0 1 2 3 z A y 8 9 i bbVbK 6 J C c u e f j k l q r s t m n o p g w v d b h a

1014  

1015  

1016cdef class _StridedMemoryViewProxy: 

1017 cdef readonly: 

1018 object obj 

1019 bint has_dlpack 

1020  

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

1022 self.obj = obj 6 ctx2L M N O P Vb

1023 self.has_dlpack = check_has_dlpack(obj) 6 ctx2L M N O P Vb

1024  

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

1026 if self.has_dlpack: 5 ctx1LMNOP

1027 return StridedMemoryView.from_dlpack(self.obj, stream_ptr) 5 ctx1LMNOP

1028 else: 

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

1030  

1031  

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

1033 cdef int dldevice, device_id 

1034 cdef bint is_device_accessible, is_readonly 

1035 is_device_accessible = False 61 ctx24 5 Y ! X R L M N O P S T U V W Z 0 1 2 3 z A y 8 9 i K 6 J D E F G H I C c u e f j k l q r s t m n o p g w v d Nbb h a Ob

1036 dldevice, device_id = obj.__dlpack_device__() 61 ctx24 5 Y ! X R L M N O P S T U V W Z 0 1 2 3 z A y 8 9 i K 6 J D E F G H I C c u e f j k l q r s t m n o p g w v d Nbb h a Ob

1037 if dldevice == _kDLCPU: 61 ctx24 5 Y ! X R L M N O P S T U V W Z 0 1 2 3 z A y 8 9 i K 6 J D E F G H I C c u e f j k l q r s t m n o p g w v d Nbb h a Ob

1038 assert device_id == 0 58 ctx2Y ! X R L M N O P S T U V W Z 0 1 2 3 z A y 8 9 i K 6 J D E F G H I C c u e f j k l q r s t m n o p g w v d Nbb h a

1039 device_id = -1 58 ctx2Y ! X R L M N O P S T U V W Z 0 1 2 3 z A y 8 9 i K 6 J D E F G H I C c u e f j k l q r s t m n o p g w v d Nbb h a

1040 if stream_ptr is None: 58 ctx2Y ! X R L M N O P S T U V W Z 0 1 2 3 z A y 8 9 i K 6 J D E F G H I C c u e f j k l q r s t m n o p g w v d Nbb h a

1041 raise BufferError("stream=None is ambiguous with view()") 1 ctx2Nb

1042 elif stream_ptr == -1: 57 ctx1Y!XRLMNOPSTUVWZ0123zAy89iK6JDEFGHICcuefjklqrstmnopgwvdbha

1043 stream_ptr = None 57 ctx1Y!XRLMNOPSTUVWZ0123zAy89iK6JDEFGHICcuefjklqrstmnopgwvdbha

1044 elif dldevice == _kDLCUDA: 

1045 assert device_id >= 0 

1046 is_device_accessible = True 

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

1048 if stream_ptr is None: 

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

1050 elif dldevice in (_kDLCUDAHost, _kDLCUDAManaged): 

1051 is_device_accessible = True 2 ctx145

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

1053 # accessed on both host and device 

1054 else: 

1055 raise BufferError("device not supported") 1 ctx2Ob

1056  

1057 cdef object capsule 

1058 try: 59 ctx145Y!XRLMNOPSTUVWZ0123zAy89iK6JDEFGHICcuefjklqrstmnopgwvdbha

1059 capsule = obj.__dlpack__( 59 ctx145Y!XRLMNOPSTUVWZ0123zAy89iK6JDEFGHICcuefjklqrstmnopgwvdbha

1060 stream=int(stream_ptr) if stream_ptr else None, 59 ctx145Y!XRLMNOPSTUVWZ0123zAy89iK6JDEFGHICcuefjklqrstmnopgwvdbha

1061 max_version=(DLPACK_MAJOR_VERSION, DLPACK_MINOR_VERSION)) 59 ctx145Y!XRLMNOPSTUVWZ0123zAy89iK6JDEFGHICcuefjklqrstmnopgwvdbha

1062 except TypeError: 2 ctx1ba

1063 capsule = obj.__dlpack__( 2 ctx1ba

1064 stream=int(stream_ptr) if stream_ptr else None) 2 ctx1ba

1065  

1066 cdef void* data = NULL 59 ctx145Y!XRLMNOPSTUVWZ0123zAy89iK6JDEFGHICcuefjklqrstmnopgwvdbha

1067 cdef DLTensor* dl_tensor 

1068 cdef DLManagedTensorVersioned* dlm_tensor_ver 

1069 cdef DLManagedTensor* dlm_tensor 

1070 cdef const char *used_name 

1071 if cpython.PyCapsule_IsValid( 59 ctx145Y!XRLMNOPSTUVWZ0123zAy89iK6JDEFGHICcuefjklqrstmnopgwvdbha

1072 capsule, DLPACK_VERSIONED_TENSOR_UNUSED_NAME): 

1073 data = cpython.PyCapsule_GetPointer( 59 ctx145Y!XRLMNOPSTUVWZ0123zAy89iK6JDEFGHICcuefjklqrstmnopgwvdbha

1074 capsule, DLPACK_VERSIONED_TENSOR_UNUSED_NAME) 

1075 dlm_tensor_ver = <DLManagedTensorVersioned*>data 59 ctx145Y!XRLMNOPSTUVWZ0123zAy89iK6JDEFGHICcuefjklqrstmnopgwvdbha

1076 dl_tensor = &dlm_tensor_ver.dl_tensor 59 ctx145Y!XRLMNOPSTUVWZ0123zAy89iK6JDEFGHICcuefjklqrstmnopgwvdbha

1077 is_readonly = bool((dlm_tensor_ver.flags & DLPACK_FLAG_BITMASK_READ_ONLY) != 0) 59 ctx145Y!XRLMNOPSTUVWZ0123zAy89iK6JDEFGHICcuefjklqrstmnopgwvdbha

1078 used_name = DLPACK_VERSIONED_TENSOR_USED_NAME 59 ctx145Y!XRLMNOPSTUVWZ0123zAy89iK6JDEFGHICcuefjklqrstmnopgwvdbha

1079 elif cpython.PyCapsule_IsValid( 2 ctx1ba

1080 capsule, DLPACK_TENSOR_UNUSED_NAME): 

1081 data = cpython.PyCapsule_GetPointer( 2 ctx1ba

1082 capsule, DLPACK_TENSOR_UNUSED_NAME) 

1083 dlm_tensor = <DLManagedTensor*>data 2 ctx1ba

1084 dl_tensor = &dlm_tensor.dl_tensor 2 ctx1ba

1085 is_readonly = False 2 ctx1ba

1086 used_name = DLPACK_TENSOR_USED_NAME 2 ctx1ba

1087 else: 

1088 assert False 

1089  

1090 cpython.PyCapsule_SetName(capsule, used_name) 59 ctx145Y!XRLMNOPSTUVWZ0123zAy89iK6JDEFGHICcuefjklqrstmnopgwvdbha

1091  

1092 cdef StridedMemoryView buf = StridedMemoryView() if view is None else view 59 ctx145Y!XRLMNOPSTUVWZ0123zAy89iK6JDEFGHICcuefjklqrstmnopgwvdbha

1093 buf.dl_tensor = dl_tensor 59 ctx145Y!XRLMNOPSTUVWZ0123zAy89iK6JDEFGHICcuefjklqrstmnopgwvdbha

1094 buf.metadata = capsule 59 ctx145Y!XRLMNOPSTUVWZ0123zAy89iK6JDEFGHICcuefjklqrstmnopgwvdbha

1095 buf.ptr = <intptr_t>(dl_tensor.data) 59 ctx145Y!XRLMNOPSTUVWZ0123zAy89iK6JDEFGHICcuefjklqrstmnopgwvdbha

1096 buf.device_id = device_id 59 ctx145Y!XRLMNOPSTUVWZ0123zAy89iK6JDEFGHICcuefjklqrstmnopgwvdbha

1097 buf.is_device_accessible = is_device_accessible 59 ctx145Y!XRLMNOPSTUVWZ0123zAy89iK6JDEFGHICcuefjklqrstmnopgwvdbha

1098 buf.readonly = is_readonly 59 ctx145Y!XRLMNOPSTUVWZ0123zAy89iK6JDEFGHICcuefjklqrstmnopgwvdbha

1099 buf.exporting_obj = obj 59 ctx145Y!XRLMNOPSTUVWZ0123zAy89iK6JDEFGHICcuefjklqrstmnopgwvdbha

1100  

1101 return buf 59 ctx145Y!XRLMNOPSTUVWZ0123zAy89iK6JDEFGHICcuefjklqrstmnopgwvdbha

1102  

1103  

1104@functools.lru_cache (empty)

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

1106 return numpy.dtype(typestr) 11 ctx1$%'()*+,-./

1107  

1108  

1109@functools.lru_cache (empty)

1110def _typestr2itemsize(str typestr) -> int: 

1111 return _typestr2dtype(typestr).itemsize 11 ctx1$%'()*+,-./

1112  

1113  

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

1115 cdef int bits = dtype.bits 31 ctx1iKDEFGHICcuefjklqrstmnopgwvdbha

1116 if dtype.lanes != 1: 31 ctx1iKDEFGHICcuefjklqrstmnopgwvdbha

1117 # TODO: return a NumPy structured dtype? 

1118 raise NotImplementedError( 

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

1120 if dtype.code == kDLUInt: 31 ctx1iKDEFGHICcuefjklqrstmnopgwvdbha