diff --git a/cuda_bindings/cuda/bindings/_v2/nvrtc.pyx b/cuda_bindings/cuda/bindings/_v2/nvrtc.pyx index 332351ea754..bbd6b93a26d 100644 --- a/cuda_bindings/cuda/bindings/_v2/nvrtc.pyx +++ b/cuda_bindings/cuda/bindings/_v2/nvrtc.pyx @@ -3,20 +3,21 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.0 to 13.4.1. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=7bea42584683721061ad6a55d7580e0a95b588f56cce22e7cfcf985235b43f1b +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=6fd79e7f27718c08c4521565c1e4f16afcbb4b6e58f45304dd40da1c8edba291 # <<<< PREAMBLE CONTENT >>>> cimport cpython as _cyb_cpython cimport cpython.buffer as _cyb_cpython_buffer +from cpython.buffer cimport ( + PyBUF_SIMPLE as _cyb_PyBUF_SIMPLE, + PyBuffer_Release as _cyb_PyBuffer_Release, + PyObject_GetBuffer as _cyb_PyObject_GetBuffer, + Py_buffer as _cyb_Py_buffer, +) from cython cimport view as _cyb_view from libc.stdint cimport intptr_t -from libc.stdlib cimport ( - calloc as _cyb_calloc, - free as _cyb_free, - malloc as _cyb_malloc, -) from libc.string cimport ( memcmp as _cyb_memcmp, memcpy as _cyb_memcpy, @@ -256,26 +257,16 @@ cdef class BundledHeadersInfo: .. seealso:: `nvrtcBundledHeadersInfo` """ cdef: + nvrtcBundledHeadersInfo _data nvrtcBundledHeadersInfo *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvrtcBundledHeadersInfo)) - if self._ptr == NULL: - raise MemoryError("Error allocating BundledHeadersInfo") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvrtcBundledHeadersInfo *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.BundledHeadersInfo object at {hex(id(self))}>" @@ -304,14 +295,20 @@ cdef class BundledHeadersInfo: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvrtcBundledHeadersInfo)) - if self._ptr == NULL: - raise MemoryError("Error allocating BundledHeadersInfo") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvrtcBundledHeadersInfo)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvrtcBundledHeadersInfo): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvrtcBundledHeadersInfo), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvrtcBundledHeadersInfo)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -408,16 +405,12 @@ cdef class BundledHeadersInfo: raise ValueError("ptr must not be null (0)") cdef BundledHeadersInfo obj = BundledHeadersInfo.__new__(BundledHeadersInfo) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvrtcBundledHeadersInfo)) - if obj._ptr == NULL: - raise MemoryError("Error allocating BundledHeadersInfo") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvrtcBundledHeadersInfo)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvrtcBundledHeadersInfo)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj diff --git a/cuda_bindings/cuda/bindings/cudla.pyx b/cuda_bindings/cuda/bindings/cudla.pyx index 67a5a8f1e5a..8170a4221a0 100644 --- a/cuda_bindings/cuda/bindings/cudla.pyx +++ b/cuda_bindings/cuda/bindings/cudla.pyx @@ -2,13 +2,19 @@ # SPDX-License-Identifier: Apache-2.0 # This code was automatically generated across versions from 1.5.0 to 13.4.1. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=88aaad5ca6606a0c26d3f7c948ab76a2695b97c973cbd771bbb66b2f6c29fef2 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=9e45316dd031b40a2b5d3cb61e6e0e249d7e27933f5cc7c99e469dddd2efdadc # <<<< PREAMBLE CONTENT >>>> cimport cpython as _cyb_cpython cimport cpython.buffer as _cyb_cpython_buffer +from cpython.buffer cimport ( + PyBUF_SIMPLE as _cyb_PyBUF_SIMPLE, + PyBuffer_Release as _cyb_PyBuffer_Release, + PyObject_GetBuffer as _cyb_PyObject_GetBuffer, + Py_buffer as _cyb_Py_buffer, +) from cython cimport view as _cyb_view from libc.stdint cimport ( intptr_t, @@ -16,11 +22,6 @@ from libc.stdint cimport ( uint64_t, uint8_t, ) -from libc.stdlib cimport ( - calloc as _cyb_calloc, - free as _cyb_free, - malloc as _cyb_malloc, -) from libc.string cimport ( memcmp as _cyb_memcmp, memcpy as _cyb_memcpy, @@ -135,26 +136,16 @@ cdef class ExternalMemoryHandleDesc: .. seealso:: `cudlaExternalMemoryHandleDesc_t` """ cdef: + cudlaExternalMemoryHandleDesc_t _data cudlaExternalMemoryHandleDesc_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(cudlaExternalMemoryHandleDesc_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating ExternalMemoryHandleDesc") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef cudlaExternalMemoryHandleDesc_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.ExternalMemoryHandleDesc object at {hex(id(self))}>" @@ -183,14 +174,20 @@ cdef class ExternalMemoryHandleDesc: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(cudlaExternalMemoryHandleDesc_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating ExternalMemoryHandleDesc") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(cudlaExternalMemoryHandleDesc_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(cudlaExternalMemoryHandleDesc_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(cudlaExternalMemoryHandleDesc_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(cudlaExternalMemoryHandleDesc_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -243,16 +240,12 @@ cdef class ExternalMemoryHandleDesc: raise ValueError("ptr must not be null (0)") cdef ExternalMemoryHandleDesc obj = ExternalMemoryHandleDesc.__new__(ExternalMemoryHandleDesc) if owner is None: - obj._ptr = _cyb_malloc(sizeof(cudlaExternalMemoryHandleDesc_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating ExternalMemoryHandleDesc") - _cyb_memcpy((obj._ptr), ptr, sizeof(cudlaExternalMemoryHandleDesc_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(cudlaExternalMemoryHandleDesc_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -277,26 +270,16 @@ cdef class ExternalSemaphoreHandleDesc: .. seealso:: `cudlaExternalSemaphoreHandleDesc_t` """ cdef: + cudlaExternalSemaphoreHandleDesc_t _data cudlaExternalSemaphoreHandleDesc_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(cudlaExternalSemaphoreHandleDesc_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating ExternalSemaphoreHandleDesc") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef cudlaExternalSemaphoreHandleDesc_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.ExternalSemaphoreHandleDesc object at {hex(id(self))}>" @@ -325,14 +308,20 @@ cdef class ExternalSemaphoreHandleDesc: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(cudlaExternalSemaphoreHandleDesc_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating ExternalSemaphoreHandleDesc") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(cudlaExternalSemaphoreHandleDesc_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(cudlaExternalSemaphoreHandleDesc_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(cudlaExternalSemaphoreHandleDesc_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(cudlaExternalSemaphoreHandleDesc_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -374,16 +363,12 @@ cdef class ExternalSemaphoreHandleDesc: raise ValueError("ptr must not be null (0)") cdef ExternalSemaphoreHandleDesc obj = ExternalSemaphoreHandleDesc.__new__(ExternalSemaphoreHandleDesc) if owner is None: - obj._ptr = _cyb_malloc(sizeof(cudlaExternalSemaphoreHandleDesc_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating ExternalSemaphoreHandleDesc") - _cyb_memcpy((obj._ptr), ptr, sizeof(cudlaExternalSemaphoreHandleDesc_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(cudlaExternalSemaphoreHandleDesc_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -419,26 +404,16 @@ cdef class ModuleTensorDescriptor: .. seealso:: `cudlaModuleTensorDescriptor` """ cdef: + cudlaModuleTensorDescriptor _data cudlaModuleTensorDescriptor *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(cudlaModuleTensorDescriptor)) - if self._ptr == NULL: - raise MemoryError("Error allocating ModuleTensorDescriptor") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef cudlaModuleTensorDescriptor *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.ModuleTensorDescriptor object at {hex(id(self))}>" @@ -467,14 +442,20 @@ cdef class ModuleTensorDescriptor: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(cudlaModuleTensorDescriptor)) - if self._ptr == NULL: - raise MemoryError("Error allocating ModuleTensorDescriptor") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(cudlaModuleTensorDescriptor)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(cudlaModuleTensorDescriptor): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(cudlaModuleTensorDescriptor), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(cudlaModuleTensorDescriptor)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -647,16 +628,12 @@ cdef class ModuleTensorDescriptor: raise ValueError("ptr must not be null (0)") cdef ModuleTensorDescriptor obj = ModuleTensorDescriptor.__new__(ModuleTensorDescriptor) if owner is None: - obj._ptr = _cyb_malloc(sizeof(cudlaModuleTensorDescriptor)) - if obj._ptr == NULL: - raise MemoryError("Error allocating ModuleTensorDescriptor") - _cyb_memcpy((obj._ptr), ptr, sizeof(cudlaModuleTensorDescriptor)) + _cyb_memcpy(&obj._data, ptr, sizeof(cudlaModuleTensorDescriptor)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -682,26 +659,16 @@ cdef class Fence: .. seealso:: `CudlaFence` """ cdef: + CudlaFence _data CudlaFence *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(CudlaFence)) - if self._ptr == NULL: - raise MemoryError("Error allocating Fence") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef CudlaFence *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.Fence object at {hex(id(self))}>" @@ -730,14 +697,20 @@ cdef class Fence: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(CudlaFence)) - if self._ptr == NULL: - raise MemoryError("Error allocating Fence") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(CudlaFence)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(CudlaFence): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(CudlaFence), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(CudlaFence)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -790,16 +763,12 @@ cdef class Fence: raise ValueError("ptr must not be null (0)") cdef Fence obj = Fence.__new__(Fence) if owner is None: - obj._ptr = _cyb_malloc(sizeof(CudlaFence)) - if obj._ptr == NULL: - raise MemoryError("Error allocating Fence") - _cyb_memcpy((obj._ptr), ptr, sizeof(CudlaFence)) + _cyb_memcpy(&obj._data, ptr, sizeof(CudlaFence)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -825,26 +794,16 @@ cdef class DevAttribute: .. seealso:: `cudlaDevAttribute` """ cdef: + cudlaDevAttribute _data cudlaDevAttribute *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(cudlaDevAttribute)) - if self._ptr == NULL: - raise MemoryError("Error allocating DevAttribute") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef cudlaDevAttribute *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.DevAttribute object at {hex(id(self))}>" @@ -873,14 +832,20 @@ cdef class DevAttribute: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(cudlaDevAttribute)) - if self._ptr == NULL: - raise MemoryError("Error allocating DevAttribute") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(cudlaDevAttribute)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(cudlaDevAttribute): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(cudlaDevAttribute), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(cudlaDevAttribute)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -933,16 +898,12 @@ cdef class DevAttribute: raise ValueError("ptr must not be null (0)") cdef DevAttribute obj = DevAttribute.__new__(DevAttribute) if owner is None: - obj._ptr = _cyb_malloc(sizeof(cudlaDevAttribute)) - if obj._ptr == NULL: - raise MemoryError("Error allocating DevAttribute") - _cyb_memcpy((obj._ptr), ptr, sizeof(cudlaDevAttribute)) + _cyb_memcpy(&obj._data, ptr, sizeof(cudlaDevAttribute)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -970,26 +931,16 @@ cdef class ModuleAttribute: .. seealso:: `cudlaModuleAttribute` """ cdef: + cudlaModuleAttribute _data cudlaModuleAttribute *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(cudlaModuleAttribute)) - if self._ptr == NULL: - raise MemoryError("Error allocating ModuleAttribute") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef cudlaModuleAttribute *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.ModuleAttribute object at {hex(id(self))}>" @@ -1018,14 +969,20 @@ cdef class ModuleAttribute: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(cudlaModuleAttribute)) - if self._ptr == NULL: - raise MemoryError("Error allocating ModuleAttribute") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(cudlaModuleAttribute)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(cudlaModuleAttribute): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(cudlaModuleAttribute), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(cudlaModuleAttribute)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -1100,16 +1057,12 @@ cdef class ModuleAttribute: raise ValueError("ptr must not be null (0)") cdef ModuleAttribute obj = ModuleAttribute.__new__(ModuleAttribute) if owner is None: - obj._ptr = _cyb_malloc(sizeof(cudlaModuleAttribute)) - if obj._ptr == NULL: - raise MemoryError("Error allocating ModuleAttribute") - _cyb_memcpy((obj._ptr), ptr, sizeof(cudlaModuleAttribute)) + _cyb_memcpy(&obj._data, ptr, sizeof(cudlaModuleAttribute)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -1135,28 +1088,18 @@ cdef class WaitEvents: .. seealso:: `cudlaWaitEvents` """ cdef: + cudlaWaitEvents _data cudlaWaitEvents *_ptr object _owner - bint _owned bint _readonly dict _refs def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(cudlaWaitEvents)) - if self._ptr == NULL: - raise MemoryError("Error allocating WaitEvents") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False self._refs = {} - def __dealloc__(self): - cdef cudlaWaitEvents *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.WaitEvents object at {hex(id(self))}>" @@ -1185,14 +1128,20 @@ cdef class WaitEvents: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(cudlaWaitEvents)) - if self._ptr == NULL: - raise MemoryError("Error allocating WaitEvents") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(cudlaWaitEvents)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(cudlaWaitEvents): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(cudlaWaitEvents), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(cudlaWaitEvents)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -1244,16 +1193,12 @@ cdef class WaitEvents: raise ValueError("ptr must not be null (0)") cdef WaitEvents obj = WaitEvents.__new__(WaitEvents) if owner is None: - obj._ptr = _cyb_malloc(sizeof(cudlaWaitEvents)) - if obj._ptr == NULL: - raise MemoryError("Error allocating WaitEvents") - _cyb_memcpy((obj._ptr), ptr, sizeof(cudlaWaitEvents)) + _cyb_memcpy(&obj._data, ptr, sizeof(cudlaWaitEvents)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly obj._refs = {} return obj @@ -1281,28 +1226,18 @@ cdef class SignalEvents: .. seealso:: `cudlaSignalEvents` """ cdef: + cudlaSignalEvents _data cudlaSignalEvents *_ptr object _owner - bint _owned bint _readonly dict _refs def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(cudlaSignalEvents)) - if self._ptr == NULL: - raise MemoryError("Error allocating SignalEvents") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False self._refs = {} - def __dealloc__(self): - cdef cudlaSignalEvents *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.SignalEvents object at {hex(id(self))}>" @@ -1331,14 +1266,20 @@ cdef class SignalEvents: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(cudlaSignalEvents)) - if self._ptr == NULL: - raise MemoryError("Error allocating SignalEvents") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(cudlaSignalEvents)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(cudlaSignalEvents): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(cudlaSignalEvents), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(cudlaSignalEvents)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -1415,16 +1356,12 @@ cdef class SignalEvents: raise ValueError("ptr must not be null (0)") cdef SignalEvents obj = SignalEvents.__new__(SignalEvents) if owner is None: - obj._ptr = _cyb_malloc(sizeof(cudlaSignalEvents)) - if obj._ptr == NULL: - raise MemoryError("Error allocating SignalEvents") - _cyb_memcpy((obj._ptr), ptr, sizeof(cudlaSignalEvents)) + _cyb_memcpy(&obj._data, ptr, sizeof(cudlaSignalEvents)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly obj._refs = {} return obj @@ -1456,28 +1393,18 @@ cdef class Task: .. seealso:: `cudlaTask` """ cdef: + cudlaTask _data cudlaTask *_ptr object _owner - bint _owned bint _readonly dict _refs def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(cudlaTask)) - if self._ptr == NULL: - raise MemoryError("Error allocating Task") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False self._refs = {} - def __dealloc__(self): - cdef cudlaTask *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.Task object at {hex(id(self))}>" @@ -1506,14 +1433,20 @@ cdef class Task: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(cudlaTask)) - if self._ptr == NULL: - raise MemoryError("Error allocating Task") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(cudlaTask)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(cudlaTask): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(cudlaTask), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(cudlaTask)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -1627,16 +1560,12 @@ cdef class Task: raise ValueError("ptr must not be null (0)") cdef Task obj = Task.__new__(Task) if owner is None: - obj._ptr = _cyb_malloc(sizeof(cudlaTask)) - if obj._ptr == NULL: - raise MemoryError("Error allocating Task") - _cyb_memcpy((obj._ptr), ptr, sizeof(cudlaTask)) + _cyb_memcpy(&obj._data, ptr, sizeof(cudlaTask)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly obj._refs = {} return obj diff --git a/cuda_bindings/cuda/bindings/cufile.pyx b/cuda_bindings/cuda/bindings/cufile.pyx index 5215e9adc49..554a2188bb3 100644 --- a/cuda_bindings/cuda/bindings/cufile.pyx +++ b/cuda_bindings/cuda/bindings/cufile.pyx @@ -3,14 +3,25 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.1 to 13.4.1. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=df140bcd5b3c6cfb01ff11bc6275a6048c37bee1db8d80a1da19b176df6af870 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=74d9436fa523346576a6e1810d4d9a85f9d84ccfa427cce5740e72723e5b9e9d # <<<< PREAMBLE CONTENT >>>> cimport cpython as _cyb_cpython cimport cpython.buffer as _cyb_cpython_buffer +from cpython.buffer cimport ( + PyBUF_SIMPLE as _cyb_PyBUF_SIMPLE, + PyBuffer_Release as _cyb_PyBuffer_Release, + PyObject_GetBuffer as _cyb_PyObject_GetBuffer, + Py_buffer as _cyb_Py_buffer, +) cimport cpython.memoryview as _cyb_cpython_memoryview +from cpython.object cimport PyObject as _cyb_PyObject +from cpython.ref cimport ( + Py_CLEAR as _cyb_Py_CLEAR, + Py_XINCREF as _cyb_Py_XINCREF, +) from cython cimport view as _cyb_view from libc.stdint cimport ( intptr_t, @@ -107,24 +118,24 @@ cdef class _py_anon_pod1: """ cdef: cuda_bindings_cufile__anon_pod1 *_ptr - object _owner - bint _owned + _cyb_PyObject *_owner bint _readonly def __init__(self): self._ptr = _cyb_calloc(1, sizeof((NULL).handle)) if self._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod1") - self._owner = None - self._owned = True + self._owner = NULL self._readonly = False def __dealloc__(self): cdef cuda_bindings_cufile__anon_pod1 *ptr - if self._owned and self._ptr != NULL: + if self._owner == NULL and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) + _cyb_Py_CLEAR(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}._py_anon_pod1 object at {hex(id(self))}>" @@ -154,14 +165,24 @@ cdef class _py_anon_pod1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof((NULL).handle)) - if self._ptr == NULL: - raise MemoryError("Error allocating _py_anon_pod1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof((NULL).handle)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof((NULL).handle): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof((NULL).handle), view.len) + ) + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_CLEAR(self._owner) + self._ptr = _cyb_malloc(sizeof((NULL).handle)) + if self._ptr == NULL: + raise MemoryError("Error allocating _py_anon_pod1") + _cyb_memcpy(self._ptr, view.buf, sizeof((NULL).handle)) + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -218,12 +239,11 @@ cdef class _py_anon_pod1: if obj._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod1") _cyb_memcpy((obj._ptr), ptr, sizeof((NULL).handle)) - obj._owner = None - obj._owned = True + obj._owner = NULL else: obj._ptr = ptr - obj._owner = owner - obj._owned = False + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -252,24 +272,24 @@ cdef class _py_anon_pod3: """ cdef: cuda_bindings_cufile__anon_pod3 *_ptr - object _owner - bint _owned + _cyb_PyObject *_owner bint _readonly def __init__(self): self._ptr = _cyb_calloc(1, sizeof((NULL).u.batch)) if self._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod3") - self._owner = None - self._owned = True + self._owner = NULL self._readonly = False def __dealloc__(self): cdef cuda_bindings_cufile__anon_pod3 *ptr - if self._owned and self._ptr != NULL: + if self._owner == NULL and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) + _cyb_Py_CLEAR(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}._py_anon_pod3 object at {hex(id(self))}>" @@ -299,14 +319,24 @@ cdef class _py_anon_pod3: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof((NULL).u.batch)) - if self._ptr == NULL: - raise MemoryError("Error allocating _py_anon_pod3") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof((NULL).u.batch)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof((NULL).u.batch): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof((NULL).u.batch), view.len) + ) + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_CLEAR(self._owner) + self._ptr = _cyb_malloc(sizeof((NULL).u.batch)) + if self._ptr == NULL: + raise MemoryError("Error allocating _py_anon_pod3") + _cyb_memcpy(self._ptr, view.buf, sizeof((NULL).u.batch)) + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -385,12 +415,11 @@ cdef class _py_anon_pod3: if obj._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod3") _cyb_memcpy((obj._ptr), ptr, sizeof((NULL).u.batch)) - obj._owner = None - obj._owned = True + obj._owner = NULL else: obj._ptr = ptr - obj._owner = owner - obj._owned = False + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -587,24 +616,24 @@ cdef class OpCounter: """ cdef: CUfileOpCounter_t *_ptr - object _owner - bint _owned + _cyb_PyObject *_owner bint _readonly def __init__(self): self._ptr = _cyb_calloc(1, sizeof(CUfileOpCounter_t)) if self._ptr == NULL: raise MemoryError("Error allocating OpCounter") - self._owner = None - self._owned = True + self._owner = NULL self._readonly = False def __dealloc__(self): cdef CUfileOpCounter_t *ptr - if self._owned and self._ptr != NULL: + if self._owner == NULL and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) + _cyb_Py_CLEAR(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}.OpCounter object at {hex(id(self))}>" @@ -634,14 +663,24 @@ cdef class OpCounter: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(CUfileOpCounter_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating OpCounter") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(CUfileOpCounter_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(CUfileOpCounter_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(CUfileOpCounter_t), view.len) + ) + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_CLEAR(self._owner) + self._ptr = _cyb_malloc(sizeof(CUfileOpCounter_t)) + if self._ptr == NULL: + raise MemoryError("Error allocating OpCounter") + _cyb_memcpy(self._ptr, view.buf, sizeof(CUfileOpCounter_t)) + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -698,12 +737,11 @@ cdef class OpCounter: if obj._ptr == NULL: raise MemoryError("Error allocating OpCounter") _cyb_memcpy((obj._ptr), ptr, sizeof(CUfileOpCounter_t)) - obj._owner = None - obj._owned = True + obj._owner = NULL else: obj._ptr = ptr - obj._owner = owner - obj._owned = False + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -1547,24 +1585,24 @@ cdef class _py_anon_pod2: """ cdef: cuda_bindings_cufile__anon_pod2 *_ptr - object _owner - bint _owned + _cyb_PyObject *_owner bint _readonly def __init__(self): self._ptr = _cyb_calloc(1, sizeof((NULL).u)) if self._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod2") - self._owner = None - self._owned = True + self._owner = NULL self._readonly = False def __dealloc__(self): cdef cuda_bindings_cufile__anon_pod2 *ptr - if self._owned and self._ptr != NULL: + if self._owner == NULL and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) + _cyb_Py_CLEAR(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}._py_anon_pod2 object at {hex(id(self))}>" @@ -1594,14 +1632,24 @@ cdef class _py_anon_pod2: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof((NULL).u)) - if self._ptr == NULL: - raise MemoryError("Error allocating _py_anon_pod2") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof((NULL).u)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof((NULL).u): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof((NULL).u), view.len) + ) + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_CLEAR(self._owner) + self._ptr = _cyb_malloc(sizeof((NULL).u)) + if self._ptr == NULL: + raise MemoryError("Error allocating _py_anon_pod2") + _cyb_memcpy(self._ptr, view.buf, sizeof((NULL).u)) + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -1652,12 +1700,11 @@ cdef class _py_anon_pod2: if obj._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod2") _cyb_memcpy((obj._ptr), ptr, sizeof((NULL).u)) - obj._owner = None - obj._owned = True + obj._owner = NULL else: obj._ptr = ptr - obj._owner = owner - obj._owned = False + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -1737,24 +1784,24 @@ cdef class StatsLevel1: """ cdef: CUfileStatsLevel1_t *_ptr - object _owner - bint _owned + _cyb_PyObject *_owner bint _readonly def __init__(self): self._ptr = _cyb_calloc(1, sizeof(CUfileStatsLevel1_t)) if self._ptr == NULL: raise MemoryError("Error allocating StatsLevel1") - self._owner = None - self._owned = True + self._owner = NULL self._readonly = False def __dealloc__(self): cdef CUfileStatsLevel1_t *ptr - if self._owned and self._ptr != NULL: + if self._owner == NULL and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) + _cyb_Py_CLEAR(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}.StatsLevel1 object at {hex(id(self))}>" @@ -1784,14 +1831,24 @@ cdef class StatsLevel1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(CUfileStatsLevel1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating StatsLevel1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(CUfileStatsLevel1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(CUfileStatsLevel1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(CUfileStatsLevel1_t), view.len) + ) + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_CLEAR(self._owner) + self._ptr = _cyb_malloc(sizeof(CUfileStatsLevel1_t)) + if self._ptr == NULL: + raise MemoryError("Error allocating StatsLevel1") + _cyb_memcpy(self._ptr, view.buf, sizeof(CUfileStatsLevel1_t)) + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -2546,12 +2603,11 @@ cdef class StatsLevel1: if obj._ptr == NULL: raise MemoryError("Error allocating StatsLevel1") _cyb_memcpy((obj._ptr), ptr, sizeof(CUfileStatsLevel1_t)) - obj._owner = None - obj._owned = True + obj._owner = NULL else: obj._ptr = ptr - obj._owner = owner - obj._owned = False + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -2771,24 +2827,24 @@ cdef class StatsLevel2: """ cdef: CUfileStatsLevel2_t *_ptr - object _owner - bint _owned + _cyb_PyObject *_owner bint _readonly def __init__(self): self._ptr = _cyb_calloc(1, sizeof(CUfileStatsLevel2_t)) if self._ptr == NULL: raise MemoryError("Error allocating StatsLevel2") - self._owner = None - self._owned = True + self._owner = NULL self._readonly = False def __dealloc__(self): cdef CUfileStatsLevel2_t *ptr - if self._owned and self._ptr != NULL: + if self._owner == NULL and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) + _cyb_Py_CLEAR(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}.StatsLevel2 object at {hex(id(self))}>" @@ -2818,14 +2874,24 @@ cdef class StatsLevel2: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(CUfileStatsLevel2_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating StatsLevel2") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(CUfileStatsLevel2_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(CUfileStatsLevel2_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(CUfileStatsLevel2_t), view.len) + ) + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_CLEAR(self._owner) + self._ptr = _cyb_malloc(sizeof(CUfileStatsLevel2_t)) + if self._ptr == NULL: + raise MemoryError("Error allocating StatsLevel2") + _cyb_memcpy(self._ptr, view.buf, sizeof(CUfileStatsLevel2_t)) + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -2910,12 +2976,11 @@ cdef class StatsLevel2: if obj._ptr == NULL: raise MemoryError("Error allocating StatsLevel2") _cyb_memcpy((obj._ptr), ptr, sizeof(CUfileStatsLevel2_t)) - obj._owner = None - obj._owned = True + obj._owner = NULL else: obj._ptr = ptr - obj._owner = owner - obj._owned = False + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -2942,26 +3007,16 @@ cdef class StatsLevel3: .. seealso:: `CUfileStatsLevel3_t` """ cdef: + CUfileStatsLevel3_t _data CUfileStatsLevel3_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(CUfileStatsLevel3_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating StatsLevel3") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef CUfileStatsLevel3_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.StatsLevel3 object at {hex(id(self))}>" @@ -2990,14 +3045,20 @@ cdef class StatsLevel3: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(CUfileStatsLevel3_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating StatsLevel3") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(CUfileStatsLevel3_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(CUfileStatsLevel3_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(CUfileStatsLevel3_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(CUfileStatsLevel3_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -3074,16 +3135,12 @@ cdef class StatsLevel3: raise ValueError("ptr must not be null (0)") cdef StatsLevel3 obj = StatsLevel3.__new__(StatsLevel3) if owner is None: - obj._ptr = _cyb_malloc(sizeof(CUfileStatsLevel3_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating StatsLevel3") - _cyb_memcpy((obj._ptr), ptr, sizeof(CUfileStatsLevel3_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(CUfileStatsLevel3_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj diff --git a/cuda_bindings/cuda/bindings/nvml.pyx b/cuda_bindings/cuda/bindings/nvml.pyx index f072ca68884..996c6434c8a 100644 --- a/cuda_bindings/cuda/bindings/nvml.pyx +++ b/cuda_bindings/cuda/bindings/nvml.pyx @@ -3,14 +3,25 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.1 to 13.4.1. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=bc9dd0fd13a3ef14daa32b5b958b5695e630f3e242a3949432186ea5a2a3f9af +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=4d010f839da36550c1c10e3d22a111851674c07a6f0fa504131b531899a4c477 # <<<< PREAMBLE CONTENT >>>> cimport cpython as _cyb_cpython cimport cpython.buffer as _cyb_cpython_buffer +from cpython.buffer cimport ( + PyBUF_SIMPLE as _cyb_PyBUF_SIMPLE, + PyBuffer_Release as _cyb_PyBuffer_Release, + PyObject_GetBuffer as _cyb_PyObject_GetBuffer, + Py_buffer as _cyb_Py_buffer, +) cimport cpython.memoryview as _cyb_cpython_memoryview +from cpython.object cimport PyObject as _cyb_PyObject +from cpython.ref cimport ( + Py_CLEAR as _cyb_Py_CLEAR, + Py_XINCREF as _cyb_Py_XINCREF, +) from cython cimport view as _cyb_view from libc.stdint cimport intptr_t from libc.stdlib cimport ( @@ -2440,26 +2451,16 @@ cdef class PciInfoExt_v1: .. seealso:: `nvmlPciInfoExt_v1_t` """ cdef: + nvmlPciInfoExt_v1_t _data nvmlPciInfoExt_v1_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlPciInfoExt_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating PciInfoExt_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlPciInfoExt_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.PciInfoExt_v1 object at {hex(id(self))}>" @@ -2488,14 +2489,20 @@ cdef class PciInfoExt_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlPciInfoExt_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating PciInfoExt_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlPciInfoExt_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlPciInfoExt_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlPciInfoExt_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlPciInfoExt_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -2629,16 +2636,12 @@ cdef class PciInfoExt_v1: raise ValueError("ptr must not be null (0)") cdef PciInfoExt_v1 obj = PciInfoExt_v1.__new__(PciInfoExt_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlPciInfoExt_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating PciInfoExt_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlPciInfoExt_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlPciInfoExt_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -2670,24 +2673,24 @@ cdef class PciInfo: """ cdef: nvmlPciInfo_t *_ptr - object _owner - bint _owned + _cyb_PyObject *_owner bint _readonly def __init__(self): self._ptr = _cyb_calloc(1, sizeof(nvmlPciInfo_t)) if self._ptr == NULL: raise MemoryError("Error allocating PciInfo") - self._owner = None - self._owned = True + self._owner = NULL self._readonly = False def __dealloc__(self): cdef nvmlPciInfo_t *ptr - if self._owned and self._ptr != NULL: + if self._owner == NULL and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) + _cyb_Py_CLEAR(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}.PciInfo object at {hex(id(self))}>" @@ -2717,14 +2720,24 @@ cdef class PciInfo: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlPciInfo_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating PciInfo") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlPciInfo_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlPciInfo_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlPciInfo_t), view.len) + ) + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_CLEAR(self._owner) + self._ptr = _cyb_malloc(sizeof(nvmlPciInfo_t)) + if self._ptr == NULL: + raise MemoryError("Error allocating PciInfo") + _cyb_memcpy(self._ptr, view.buf, sizeof(nvmlPciInfo_t)) + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -2844,12 +2857,11 @@ cdef class PciInfo: if obj._ptr == NULL: raise MemoryError("Error allocating PciInfo") _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlPciInfo_t)) - obj._owner = None - obj._owned = True + obj._owner = NULL else: obj._ptr = ptr - obj._owner = owner - obj._owned = False + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -2875,26 +2887,16 @@ cdef class Utilization: .. seealso:: `nvmlUtilization_t` """ cdef: + nvmlUtilization_t _data nvmlUtilization_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlUtilization_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating Utilization") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlUtilization_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.Utilization object at {hex(id(self))}>" @@ -2923,14 +2925,20 @@ cdef class Utilization: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlUtilization_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating Utilization") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlUtilization_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlUtilization_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlUtilization_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlUtilization_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -2983,16 +2991,12 @@ cdef class Utilization: raise ValueError("ptr must not be null (0)") cdef Utilization obj = Utilization.__new__(Utilization) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlUtilization_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating Utilization") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlUtilization_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlUtilization_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -3019,26 +3023,16 @@ cdef class Memory: .. seealso:: `nvmlMemory_t` """ cdef: + nvmlMemory_t _data nvmlMemory_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlMemory_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating Memory") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlMemory_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.Memory object at {hex(id(self))}>" @@ -3067,14 +3061,20 @@ cdef class Memory: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlMemory_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating Memory") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlMemory_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlMemory_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlMemory_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlMemory_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -3138,16 +3138,12 @@ cdef class Memory: raise ValueError("ptr must not be null (0)") cdef Memory obj = Memory.__new__(Memory) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlMemory_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating Memory") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlMemory_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlMemory_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -3176,26 +3172,16 @@ cdef class Memory_v2: .. seealso:: `nvmlMemory_v2_t` """ cdef: + nvmlMemory_v2_t _data nvmlMemory_v2_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlMemory_v2_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating Memory_v2") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlMemory_v2_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.Memory_v2 object at {hex(id(self))}>" @@ -3224,14 +3210,20 @@ cdef class Memory_v2: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlMemory_v2_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating Memory_v2") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlMemory_v2_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlMemory_v2_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlMemory_v2_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlMemory_v2_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -3317,16 +3309,12 @@ cdef class Memory_v2: raise ValueError("ptr must not be null (0)") cdef Memory_v2 obj = Memory_v2.__new__(Memory_v2) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlMemory_v2_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating Memory_v2") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlMemory_v2_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlMemory_v2_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -3353,26 +3341,16 @@ cdef class BAR1Memory: .. seealso:: `nvmlBAR1Memory_t` """ cdef: + nvmlBAR1Memory_t _data nvmlBAR1Memory_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlBAR1Memory_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating BAR1Memory") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlBAR1Memory_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.BAR1Memory object at {hex(id(self))}>" @@ -3401,14 +3379,20 @@ cdef class BAR1Memory: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlBAR1Memory_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating BAR1Memory") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlBAR1Memory_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlBAR1Memory_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlBAR1Memory_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlBAR1Memory_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -3472,16 +3456,12 @@ cdef class BAR1Memory: raise ValueError("ptr must not be null (0)") cdef BAR1Memory obj = BAR1Memory.__new__(BAR1Memory) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlBAR1Memory_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating BAR1Memory") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlBAR1Memory_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlBAR1Memory_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -3890,26 +3870,16 @@ cdef class DeviceAttributes: .. seealso:: `nvmlDeviceAttributes_t` """ cdef: + nvmlDeviceAttributes_t _data nvmlDeviceAttributes_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlDeviceAttributes_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating DeviceAttributes") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlDeviceAttributes_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.DeviceAttributes object at {hex(id(self))}>" @@ -3938,14 +3908,20 @@ cdef class DeviceAttributes: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlDeviceAttributes_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating DeviceAttributes") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlDeviceAttributes_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlDeviceAttributes_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlDeviceAttributes_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlDeviceAttributes_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -4075,16 +4051,12 @@ cdef class DeviceAttributes: raise ValueError("ptr must not be null (0)") cdef DeviceAttributes obj = DeviceAttributes.__new__(DeviceAttributes) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlDeviceAttributes_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating DeviceAttributes") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlDeviceAttributes_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlDeviceAttributes_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -4109,26 +4081,16 @@ cdef class C2cModeInfo_v1: .. seealso:: `nvmlC2cModeInfo_v1_t` """ cdef: + nvmlC2cModeInfo_v1_t _data nvmlC2cModeInfo_v1_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlC2cModeInfo_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating C2cModeInfo_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlC2cModeInfo_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.C2cModeInfo_v1 object at {hex(id(self))}>" @@ -4157,14 +4119,20 @@ cdef class C2cModeInfo_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlC2cModeInfo_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating C2cModeInfo_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlC2cModeInfo_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlC2cModeInfo_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlC2cModeInfo_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlC2cModeInfo_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -4206,16 +4174,12 @@ cdef class C2cModeInfo_v1: raise ValueError("ptr must not be null (0)") cdef C2cModeInfo_v1 obj = C2cModeInfo_v1.__new__(C2cModeInfo_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlC2cModeInfo_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating C2cModeInfo_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlC2cModeInfo_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlC2cModeInfo_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -4244,26 +4208,16 @@ cdef class RowRemapperHistogramValues: .. seealso:: `nvmlRowRemapperHistogramValues_t` """ cdef: + nvmlRowRemapperHistogramValues_t _data nvmlRowRemapperHistogramValues_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlRowRemapperHistogramValues_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating RowRemapperHistogramValues") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlRowRemapperHistogramValues_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.RowRemapperHistogramValues object at {hex(id(self))}>" @@ -4292,14 +4246,20 @@ cdef class RowRemapperHistogramValues: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlRowRemapperHistogramValues_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating RowRemapperHistogramValues") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlRowRemapperHistogramValues_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlRowRemapperHistogramValues_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlRowRemapperHistogramValues_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlRowRemapperHistogramValues_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -4385,16 +4345,12 @@ cdef class RowRemapperHistogramValues: raise ValueError("ptr must not be null (0)") cdef RowRemapperHistogramValues obj = RowRemapperHistogramValues.__new__(RowRemapperHistogramValues) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlRowRemapperHistogramValues_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating RowRemapperHistogramValues") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlRowRemapperHistogramValues_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlRowRemapperHistogramValues_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -4584,24 +4540,24 @@ cdef class Value: """ cdef: nvmlValue_t *_ptr - object _owner - bint _owned + _cyb_PyObject *_owner bint _readonly def __init__(self): self._ptr = _cyb_calloc(1, sizeof(nvmlValue_t)) if self._ptr == NULL: raise MemoryError("Error allocating Value") - self._owner = None - self._owned = True + self._owner = NULL self._readonly = False def __dealloc__(self): cdef nvmlValue_t *ptr - if self._owned and self._ptr != NULL: + if self._owner == NULL and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) + _cyb_Py_CLEAR(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}.Value object at {hex(id(self))}>" @@ -4631,14 +4587,24 @@ cdef class Value: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlValue_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating Value") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlValue_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlValue_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlValue_t), view.len) + ) + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_CLEAR(self._owner) + self._ptr = _cyb_malloc(sizeof(nvmlValue_t)) + if self._ptr == NULL: + raise MemoryError("Error allocating Value") + _cyb_memcpy(self._ptr, view.buf, sizeof(nvmlValue_t)) + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -4750,12 +4716,11 @@ cdef class Value: if obj._ptr == NULL: raise MemoryError("Error allocating Value") _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlValue_t)) - obj._owner = None - obj._owned = True + obj._owner = NULL else: obj._ptr = ptr - obj._owner = owner - obj._owned = False + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -4977,26 +4942,16 @@ cdef class CoolerInfo_v1: .. seealso:: `nvmlCoolerInfo_v1_t` """ cdef: + nvmlCoolerInfo_v1_t _data nvmlCoolerInfo_v1_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlCoolerInfo_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating CoolerInfo_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlCoolerInfo_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.CoolerInfo_v1 object at {hex(id(self))}>" @@ -5025,14 +4980,20 @@ cdef class CoolerInfo_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlCoolerInfo_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating CoolerInfo_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlCoolerInfo_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlCoolerInfo_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlCoolerInfo_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlCoolerInfo_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -5107,16 +5068,12 @@ cdef class CoolerInfo_v1: raise ValueError("ptr must not be null (0)") cdef CoolerInfo_v1 obj = CoolerInfo_v1.__new__(CoolerInfo_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlCoolerInfo_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating CoolerInfo_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlCoolerInfo_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlCoolerInfo_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -5304,26 +5261,16 @@ cdef class ClockOffset_v1: .. seealso:: `nvmlClockOffset_v1_t` """ cdef: + nvmlClockOffset_v1_t _data nvmlClockOffset_v1_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlClockOffset_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating ClockOffset_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlClockOffset_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.ClockOffset_v1 object at {hex(id(self))}>" @@ -5352,14 +5299,20 @@ cdef class ClockOffset_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlClockOffset_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating ClockOffset_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlClockOffset_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlClockOffset_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlClockOffset_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlClockOffset_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -5456,16 +5409,12 @@ cdef class ClockOffset_v1: raise ValueError("ptr must not be null (0)") cdef ClockOffset_v1 obj = ClockOffset_v1.__new__(ClockOffset_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlClockOffset_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating ClockOffset_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlClockOffset_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlClockOffset_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -5938,26 +5887,16 @@ cdef class EccSramErrorStatus_v1: .. seealso:: `nvmlEccSramErrorStatus_v1_t` """ cdef: + nvmlEccSramErrorStatus_v1_t _data nvmlEccSramErrorStatus_v1_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlEccSramErrorStatus_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating EccSramErrorStatus_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlEccSramErrorStatus_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.EccSramErrorStatus_v1 object at {hex(id(self))}>" @@ -5986,14 +5925,20 @@ cdef class EccSramErrorStatus_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlEccSramErrorStatus_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating EccSramErrorStatus_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlEccSramErrorStatus_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlEccSramErrorStatus_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlEccSramErrorStatus_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlEccSramErrorStatus_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -6167,16 +6112,12 @@ cdef class EccSramErrorStatus_v1: raise ValueError("ptr must not be null (0)") cdef EccSramErrorStatus_v1 obj = EccSramErrorStatus_v1.__new__(EccSramErrorStatus_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlEccSramErrorStatus_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating EccSramErrorStatus_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlEccSramErrorStatus_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlEccSramErrorStatus_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -6208,26 +6149,16 @@ cdef class PlatformInfo_v1: .. seealso:: `nvmlPlatformInfo_v1_t` """ cdef: + nvmlPlatformInfo_v1_t _data nvmlPlatformInfo_v1_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlPlatformInfo_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating PlatformInfo_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlPlatformInfo_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.PlatformInfo_v1 object at {hex(id(self))}>" @@ -6256,14 +6187,20 @@ cdef class PlatformInfo_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlPlatformInfo_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating PlatformInfo_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlPlatformInfo_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlPlatformInfo_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlPlatformInfo_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlPlatformInfo_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -6394,16 +6331,12 @@ cdef class PlatformInfo_v1: raise ValueError("ptr must not be null (0)") cdef PlatformInfo_v1 obj = PlatformInfo_v1.__new__(PlatformInfo_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlPlatformInfo_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating PlatformInfo_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlPlatformInfo_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlPlatformInfo_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -6435,26 +6368,16 @@ cdef class PlatformInfo_v2: .. seealso:: `nvmlPlatformInfo_v2_t` """ cdef: + nvmlPlatformInfo_v2_t _data nvmlPlatformInfo_v2_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlPlatformInfo_v2_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating PlatformInfo_v2") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlPlatformInfo_v2_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.PlatformInfo_v2 object at {hex(id(self))}>" @@ -6483,14 +6406,20 @@ cdef class PlatformInfo_v2: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlPlatformInfo_v2_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating PlatformInfo_v2") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlPlatformInfo_v2_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlPlatformInfo_v2_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlPlatformInfo_v2_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlPlatformInfo_v2_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -6621,16 +6550,12 @@ cdef class PlatformInfo_v2: raise ValueError("ptr must not be null (0)") cdef PlatformInfo_v2 obj = PlatformInfo_v2.__new__(PlatformInfo_v2) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlPlatformInfo_v2_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating PlatformInfo_v2") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlPlatformInfo_v2_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlPlatformInfo_v2_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -6841,28 +6766,18 @@ cdef class VgpuPlacementList_v2: .. seealso:: `nvmlVgpuPlacementList_v2_t` """ cdef: + nvmlVgpuPlacementList_v2_t _data nvmlVgpuPlacementList_v2_t *_ptr object _owner - bint _owned bint _readonly dict _refs def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlVgpuPlacementList_v2_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuPlacementList_v2") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False self._refs = {} - def __dealloc__(self): - cdef nvmlVgpuPlacementList_v2_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.VgpuPlacementList_v2 object at {hex(id(self))}>" @@ -6891,14 +6806,20 @@ cdef class VgpuPlacementList_v2: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlVgpuPlacementList_v2_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuPlacementList_v2") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlVgpuPlacementList_v2_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlVgpuPlacementList_v2_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlVgpuPlacementList_v2_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlVgpuPlacementList_v2_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -6981,16 +6902,12 @@ cdef class VgpuPlacementList_v2: raise ValueError("ptr must not be null (0)") cdef VgpuPlacementList_v2 obj = VgpuPlacementList_v2.__new__(VgpuPlacementList_v2) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlVgpuPlacementList_v2_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating VgpuPlacementList_v2") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlVgpuPlacementList_v2_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlVgpuPlacementList_v2_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly obj._refs = {} return obj @@ -7017,26 +6934,16 @@ cdef class VgpuTypeBar1Info_v1: .. seealso:: `nvmlVgpuTypeBar1Info_v1_t` """ cdef: + nvmlVgpuTypeBar1Info_v1_t _data nvmlVgpuTypeBar1Info_v1_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlVgpuTypeBar1Info_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuTypeBar1Info_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlVgpuTypeBar1Info_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.VgpuTypeBar1Info_v1 object at {hex(id(self))}>" @@ -7065,14 +6972,20 @@ cdef class VgpuTypeBar1Info_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlVgpuTypeBar1Info_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuTypeBar1Info_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlVgpuTypeBar1Info_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlVgpuTypeBar1Info_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlVgpuTypeBar1Info_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlVgpuTypeBar1Info_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -7125,16 +7038,12 @@ cdef class VgpuTypeBar1Info_v1: raise ValueError("ptr must not be null (0)") cdef VgpuTypeBar1Info_v1 obj = VgpuTypeBar1Info_v1.__new__(VgpuTypeBar1Info_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlVgpuTypeBar1Info_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating VgpuTypeBar1Info_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlVgpuTypeBar1Info_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlVgpuTypeBar1Info_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -7413,24 +7322,24 @@ cdef class _py_anon_pod2: """ cdef: cuda_bindings_nvml__anon_pod2 *_ptr - object _owner - bint _owned + _cyb_PyObject *_owner bint _readonly def __init__(self): self._ptr = _cyb_calloc(1, sizeof(cuda_bindings_nvml__anon_pod2)) if self._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod2") - self._owner = None - self._owned = True + self._owner = NULL self._readonly = False def __dealloc__(self): cdef cuda_bindings_nvml__anon_pod2 *ptr - if self._owned and self._ptr != NULL: + if self._owner == NULL and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) + _cyb_Py_CLEAR(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}._py_anon_pod2 object at {hex(id(self))}>" @@ -7460,14 +7369,24 @@ cdef class _py_anon_pod2: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(cuda_bindings_nvml__anon_pod2)) - if self._ptr == NULL: - raise MemoryError("Error allocating _py_anon_pod2") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(cuda_bindings_nvml__anon_pod2)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(cuda_bindings_nvml__anon_pod2): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(cuda_bindings_nvml__anon_pod2), view.len) + ) + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_CLEAR(self._owner) + self._ptr = _cyb_malloc(sizeof(cuda_bindings_nvml__anon_pod2)) + if self._ptr == NULL: + raise MemoryError("Error allocating _py_anon_pod2") + _cyb_memcpy(self._ptr, view.buf, sizeof(cuda_bindings_nvml__anon_pod2)) + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -7524,12 +7443,11 @@ cdef class _py_anon_pod2: if obj._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod2") _cyb_memcpy((obj._ptr), ptr, sizeof(cuda_bindings_nvml__anon_pod2)) - obj._owner = None - obj._owned = True + obj._owner = NULL else: obj._ptr = ptr - obj._owner = owner - obj._owned = False + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -7555,24 +7473,24 @@ cdef class _py_anon_pod3: """ cdef: cuda_bindings_nvml__anon_pod3 *_ptr - object _owner - bint _owned + _cyb_PyObject *_owner bint _readonly def __init__(self): self._ptr = _cyb_calloc(1, sizeof(cuda_bindings_nvml__anon_pod3)) if self._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod3") - self._owner = None - self._owned = True + self._owner = NULL self._readonly = False def __dealloc__(self): cdef cuda_bindings_nvml__anon_pod3 *ptr - if self._owned and self._ptr != NULL: + if self._owner == NULL and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) + _cyb_Py_CLEAR(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}._py_anon_pod3 object at {hex(id(self))}>" @@ -7602,14 +7520,24 @@ cdef class _py_anon_pod3: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(cuda_bindings_nvml__anon_pod3)) - if self._ptr == NULL: - raise MemoryError("Error allocating _py_anon_pod3") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(cuda_bindings_nvml__anon_pod3)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(cuda_bindings_nvml__anon_pod3): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(cuda_bindings_nvml__anon_pod3), view.len) + ) + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_CLEAR(self._owner) + self._ptr = _cyb_malloc(sizeof(cuda_bindings_nvml__anon_pod3)) + if self._ptr == NULL: + raise MemoryError("Error allocating _py_anon_pod3") + _cyb_memcpy(self._ptr, view.buf, sizeof(cuda_bindings_nvml__anon_pod3)) + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -7655,12 +7583,11 @@ cdef class _py_anon_pod3: if obj._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod3") _cyb_memcpy((obj._ptr), ptr, sizeof(cuda_bindings_nvml__anon_pod3)) - obj._owner = None - obj._owned = True + obj._owner = NULL else: obj._ptr = ptr - obj._owner = owner - obj._owned = False + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -7893,24 +7820,24 @@ cdef class _py_anon_pod4: """ cdef: cuda_bindings_nvml__anon_pod4 *_ptr - object _owner - bint _owned + _cyb_PyObject *_owner bint _readonly def __init__(self): self._ptr = _cyb_calloc(1, sizeof(cuda_bindings_nvml__anon_pod4)) if self._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod4") - self._owner = None - self._owned = True + self._owner = NULL self._readonly = False def __dealloc__(self): cdef cuda_bindings_nvml__anon_pod4 *ptr - if self._owned and self._ptr != NULL: + if self._owner == NULL and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) + _cyb_Py_CLEAR(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}._py_anon_pod4 object at {hex(id(self))}>" @@ -7940,14 +7867,24 @@ cdef class _py_anon_pod4: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(cuda_bindings_nvml__anon_pod4)) - if self._ptr == NULL: - raise MemoryError("Error allocating _py_anon_pod4") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(cuda_bindings_nvml__anon_pod4)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(cuda_bindings_nvml__anon_pod4): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(cuda_bindings_nvml__anon_pod4), view.len) + ) + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_CLEAR(self._owner) + self._ptr = _cyb_malloc(sizeof(cuda_bindings_nvml__anon_pod4)) + if self._ptr == NULL: + raise MemoryError("Error allocating _py_anon_pod4") + _cyb_memcpy(self._ptr, view.buf, sizeof(cuda_bindings_nvml__anon_pod4)) + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -8004,12 +7941,11 @@ cdef class _py_anon_pod4: if obj._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod4") _cyb_memcpy((obj._ptr), ptr, sizeof(cuda_bindings_nvml__anon_pod4)) - obj._owner = None - obj._owned = True + obj._owner = NULL else: obj._ptr = ptr - obj._owner = owner - obj._owned = False + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -8035,24 +7971,24 @@ cdef class _py_anon_pod5: """ cdef: cuda_bindings_nvml__anon_pod5 *_ptr - object _owner - bint _owned + _cyb_PyObject *_owner bint _readonly def __init__(self): self._ptr = _cyb_calloc(1, sizeof(cuda_bindings_nvml__anon_pod5)) if self._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod5") - self._owner = None - self._owned = True + self._owner = NULL self._readonly = False def __dealloc__(self): cdef cuda_bindings_nvml__anon_pod5 *ptr - if self._owned and self._ptr != NULL: + if self._owner == NULL and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) + _cyb_Py_CLEAR(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}._py_anon_pod5 object at {hex(id(self))}>" @@ -8082,14 +8018,24 @@ cdef class _py_anon_pod5: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(cuda_bindings_nvml__anon_pod5)) - if self._ptr == NULL: - raise MemoryError("Error allocating _py_anon_pod5") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(cuda_bindings_nvml__anon_pod5)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(cuda_bindings_nvml__anon_pod5): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(cuda_bindings_nvml__anon_pod5), view.len) + ) + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_CLEAR(self._owner) + self._ptr = _cyb_malloc(sizeof(cuda_bindings_nvml__anon_pod5)) + if self._ptr == NULL: + raise MemoryError("Error allocating _py_anon_pod5") + _cyb_memcpy(self._ptr, view.buf, sizeof(cuda_bindings_nvml__anon_pod5)) + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -8135,12 +8081,11 @@ cdef class _py_anon_pod5: if obj._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod5") _cyb_memcpy((obj._ptr), ptr, sizeof(cuda_bindings_nvml__anon_pod5)) - obj._owner = None - obj._owned = True + obj._owner = NULL else: obj._ptr = ptr - obj._owner = owner - obj._owned = False + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -8172,26 +8117,16 @@ cdef class VgpuSchedulerCapabilities: .. seealso:: `nvmlVgpuSchedulerCapabilities_t` """ cdef: + nvmlVgpuSchedulerCapabilities_t _data nvmlVgpuSchedulerCapabilities_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlVgpuSchedulerCapabilities_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuSchedulerCapabilities") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlVgpuSchedulerCapabilities_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.VgpuSchedulerCapabilities object at {hex(id(self))}>" @@ -8220,14 +8155,20 @@ cdef class VgpuSchedulerCapabilities: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlVgpuSchedulerCapabilities_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuSchedulerCapabilities") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlVgpuSchedulerCapabilities_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlVgpuSchedulerCapabilities_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlVgpuSchedulerCapabilities_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlVgpuSchedulerCapabilities_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -8352,16 +8293,12 @@ cdef class VgpuSchedulerCapabilities: raise ValueError("ptr must not be null (0)") cdef VgpuSchedulerCapabilities obj = VgpuSchedulerCapabilities.__new__(VgpuSchedulerCapabilities) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlVgpuSchedulerCapabilities_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating VgpuSchedulerCapabilities") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlVgpuSchedulerCapabilities_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlVgpuSchedulerCapabilities_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -8393,24 +8330,24 @@ cdef class VgpuLicenseExpiry: """ cdef: nvmlVgpuLicenseExpiry_t *_ptr - object _owner - bint _owned + _cyb_PyObject *_owner bint _readonly def __init__(self): self._ptr = _cyb_calloc(1, sizeof(nvmlVgpuLicenseExpiry_t)) if self._ptr == NULL: raise MemoryError("Error allocating VgpuLicenseExpiry") - self._owner = None - self._owned = True + self._owner = NULL self._readonly = False def __dealloc__(self): cdef nvmlVgpuLicenseExpiry_t *ptr - if self._owned and self._ptr != NULL: + if self._owner == NULL and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) + _cyb_Py_CLEAR(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}.VgpuLicenseExpiry object at {hex(id(self))}>" @@ -8440,14 +8377,24 @@ cdef class VgpuLicenseExpiry: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlVgpuLicenseExpiry_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuLicenseExpiry") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlVgpuLicenseExpiry_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlVgpuLicenseExpiry_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlVgpuLicenseExpiry_t), view.len) + ) + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_CLEAR(self._owner) + self._ptr = _cyb_malloc(sizeof(nvmlVgpuLicenseExpiry_t)) + if self._ptr == NULL: + raise MemoryError("Error allocating VgpuLicenseExpiry") + _cyb_memcpy(self._ptr, view.buf, sizeof(nvmlVgpuLicenseExpiry_t)) + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -8559,12 +8506,11 @@ cdef class VgpuLicenseExpiry: if obj._ptr == NULL: raise MemoryError("Error allocating VgpuLicenseExpiry") _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlVgpuLicenseExpiry_t)) - obj._owner = None - obj._owned = True + obj._owner = NULL else: obj._ptr = ptr - obj._owner = owner - obj._owned = False + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -8596,24 +8542,24 @@ cdef class GridLicenseExpiry: """ cdef: nvmlGridLicenseExpiry_t *_ptr - object _owner - bint _owned + _cyb_PyObject *_owner bint _readonly def __init__(self): self._ptr = _cyb_calloc(1, sizeof(nvmlGridLicenseExpiry_t)) if self._ptr == NULL: raise MemoryError("Error allocating GridLicenseExpiry") - self._owner = None - self._owned = True + self._owner = NULL self._readonly = False def __dealloc__(self): cdef nvmlGridLicenseExpiry_t *ptr - if self._owned and self._ptr != NULL: + if self._owner == NULL and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) + _cyb_Py_CLEAR(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}.GridLicenseExpiry object at {hex(id(self))}>" @@ -8643,14 +8589,24 @@ cdef class GridLicenseExpiry: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlGridLicenseExpiry_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating GridLicenseExpiry") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlGridLicenseExpiry_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlGridLicenseExpiry_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlGridLicenseExpiry_t), view.len) + ) + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_CLEAR(self._owner) + self._ptr = _cyb_malloc(sizeof(nvmlGridLicenseExpiry_t)) + if self._ptr == NULL: + raise MemoryError("Error allocating GridLicenseExpiry") + _cyb_memcpy(self._ptr, view.buf, sizeof(nvmlGridLicenseExpiry_t)) + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -8762,12 +8718,11 @@ cdef class GridLicenseExpiry: if obj._ptr == NULL: raise MemoryError("Error allocating GridLicenseExpiry") _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlGridLicenseExpiry_t)) - obj._owner = None - obj._owned = True + obj._owner = NULL else: obj._ptr = ptr - obj._owner = owner - obj._owned = False + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -8794,28 +8749,18 @@ cdef class VgpuTypeIdInfo_v1: .. seealso:: `nvmlVgpuTypeIdInfo_v1_t` """ cdef: + nvmlVgpuTypeIdInfo_v1_t _data nvmlVgpuTypeIdInfo_v1_t *_ptr object _owner - bint _owned bint _readonly dict _refs def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlVgpuTypeIdInfo_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuTypeIdInfo_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False self._refs = {} - def __dealloc__(self): - cdef nvmlVgpuTypeIdInfo_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.VgpuTypeIdInfo_v1 object at {hex(id(self))}>" @@ -8844,14 +8789,20 @@ cdef class VgpuTypeIdInfo_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlVgpuTypeIdInfo_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuTypeIdInfo_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlVgpuTypeIdInfo_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlVgpuTypeIdInfo_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlVgpuTypeIdInfo_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlVgpuTypeIdInfo_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -8912,16 +8863,12 @@ cdef class VgpuTypeIdInfo_v1: raise ValueError("ptr must not be null (0)") cdef VgpuTypeIdInfo_v1 obj = VgpuTypeIdInfo_v1.__new__(VgpuTypeIdInfo_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlVgpuTypeIdInfo_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating VgpuTypeIdInfo_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlVgpuTypeIdInfo_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlVgpuTypeIdInfo_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly obj._refs = {} return obj @@ -8949,28 +8896,18 @@ cdef class ActiveVgpuInstanceInfo_v1: .. seealso:: `nvmlActiveVgpuInstanceInfo_v1_t` """ cdef: + nvmlActiveVgpuInstanceInfo_v1_t _data nvmlActiveVgpuInstanceInfo_v1_t *_ptr object _owner - bint _owned bint _readonly dict _refs def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlActiveVgpuInstanceInfo_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating ActiveVgpuInstanceInfo_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False self._refs = {} - def __dealloc__(self): - cdef nvmlActiveVgpuInstanceInfo_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.ActiveVgpuInstanceInfo_v1 object at {hex(id(self))}>" @@ -8999,14 +8936,20 @@ cdef class ActiveVgpuInstanceInfo_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlActiveVgpuInstanceInfo_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating ActiveVgpuInstanceInfo_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlActiveVgpuInstanceInfo_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlActiveVgpuInstanceInfo_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlActiveVgpuInstanceInfo_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlActiveVgpuInstanceInfo_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -9067,16 +9010,12 @@ cdef class ActiveVgpuInstanceInfo_v1: raise ValueError("ptr must not be null (0)") cdef ActiveVgpuInstanceInfo_v1 obj = ActiveVgpuInstanceInfo_v1.__new__(ActiveVgpuInstanceInfo_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlActiveVgpuInstanceInfo_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating ActiveVgpuInstanceInfo_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlActiveVgpuInstanceInfo_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlActiveVgpuInstanceInfo_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly obj._refs = {} return obj @@ -9106,28 +9045,18 @@ cdef class VgpuCreatablePlacementInfo_v1: .. seealso:: `nvmlVgpuCreatablePlacementInfo_v1_t` """ cdef: + nvmlVgpuCreatablePlacementInfo_v1_t _data nvmlVgpuCreatablePlacementInfo_v1_t *_ptr object _owner - bint _owned bint _readonly dict _refs def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlVgpuCreatablePlacementInfo_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuCreatablePlacementInfo_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False self._refs = {} - def __dealloc__(self): - cdef nvmlVgpuCreatablePlacementInfo_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.VgpuCreatablePlacementInfo_v1 object at {hex(id(self))}>" @@ -9156,14 +9085,20 @@ cdef class VgpuCreatablePlacementInfo_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlVgpuCreatablePlacementInfo_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuCreatablePlacementInfo_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlVgpuCreatablePlacementInfo_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlVgpuCreatablePlacementInfo_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlVgpuCreatablePlacementInfo_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlVgpuCreatablePlacementInfo_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -9246,16 +9181,12 @@ cdef class VgpuCreatablePlacementInfo_v1: raise ValueError("ptr must not be null (0)") cdef VgpuCreatablePlacementInfo_v1 obj = VgpuCreatablePlacementInfo_v1.__new__(VgpuCreatablePlacementInfo_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlVgpuCreatablePlacementInfo_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating VgpuCreatablePlacementInfo_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlVgpuCreatablePlacementInfo_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlVgpuCreatablePlacementInfo_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly obj._refs = {} return obj @@ -9438,26 +9369,16 @@ cdef class LedState: .. seealso:: `nvmlLedState_t` """ cdef: + nvmlLedState_t _data nvmlLedState_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlLedState_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating LedState") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlLedState_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.LedState object at {hex(id(self))}>" @@ -9486,14 +9407,20 @@ cdef class LedState: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlLedState_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating LedState") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlLedState_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlLedState_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlLedState_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlLedState_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -9550,16 +9477,12 @@ cdef class LedState: raise ValueError("ptr must not be null (0)") cdef LedState obj = LedState.__new__(LedState) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlLedState_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating LedState") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlLedState_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlLedState_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -9587,26 +9510,16 @@ cdef class UnitInfo: .. seealso:: `nvmlUnitInfo_t` """ cdef: + nvmlUnitInfo_t _data nvmlUnitInfo_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlUnitInfo_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating UnitInfo") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlUnitInfo_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.UnitInfo object at {hex(id(self))}>" @@ -9635,14 +9548,20 @@ cdef class UnitInfo: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlUnitInfo_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating UnitInfo") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlUnitInfo_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlUnitInfo_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlUnitInfo_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlUnitInfo_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -9733,16 +9652,12 @@ cdef class UnitInfo: raise ValueError("ptr must not be null (0)") cdef UnitInfo obj = UnitInfo.__new__(UnitInfo) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlUnitInfo_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating UnitInfo") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlUnitInfo_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlUnitInfo_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -9770,26 +9685,16 @@ cdef class PSUInfo: .. seealso:: `nvmlPSUInfo_t` """ cdef: + nvmlPSUInfo_t _data nvmlPSUInfo_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlPSUInfo_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating PSUInfo") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlPSUInfo_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.PSUInfo object at {hex(id(self))}>" @@ -9818,14 +9723,20 @@ cdef class PSUInfo: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlPSUInfo_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating PSUInfo") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlPSUInfo_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlPSUInfo_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlPSUInfo_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlPSUInfo_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -9904,16 +9815,12 @@ cdef class PSUInfo: raise ValueError("ptr must not be null (0)") cdef PSUInfo obj = PSUInfo.__new__(PSUInfo) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlPSUInfo_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating PSUInfo") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlPSUInfo_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlPSUInfo_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -10100,26 +10007,16 @@ cdef class EventData: .. seealso:: `nvmlEventData_t` """ cdef: + nvmlEventData_t _data nvmlEventData_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlEventData_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating EventData") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlEventData_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.EventData object at {hex(id(self))}>" @@ -10148,14 +10045,20 @@ cdef class EventData: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlEventData_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating EventData") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlEventData_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlEventData_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlEventData_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlEventData_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -10241,16 +10144,12 @@ cdef class EventData: raise ValueError("ptr must not be null (0)") cdef EventData obj = EventData.__new__(EventData) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlEventData_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating EventData") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlEventData_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlEventData_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -10439,26 +10338,16 @@ cdef class AccountingStats: .. seealso:: `nvmlAccountingStats_t` """ cdef: + nvmlAccountingStats_t _data nvmlAccountingStats_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlAccountingStats_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating AccountingStats") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlAccountingStats_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.AccountingStats object at {hex(id(self))}>" @@ -10487,14 +10376,20 @@ cdef class AccountingStats: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlAccountingStats_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating AccountingStats") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlAccountingStats_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlAccountingStats_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlAccountingStats_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlAccountingStats_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -10591,16 +10486,12 @@ cdef class AccountingStats: raise ValueError("ptr must not be null (0)") cdef AccountingStats obj = AccountingStats.__new__(AccountingStats) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlAccountingStats_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating AccountingStats") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlAccountingStats_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlAccountingStats_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -10857,26 +10748,16 @@ cdef class FBCStats: .. seealso:: `nvmlFBCStats_t` """ cdef: + nvmlFBCStats_t _data nvmlFBCStats_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlFBCStats_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating FBCStats") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlFBCStats_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.FBCStats object at {hex(id(self))}>" @@ -10905,14 +10786,20 @@ cdef class FBCStats: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlFBCStats_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating FBCStats") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlFBCStats_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlFBCStats_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlFBCStats_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlFBCStats_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -10976,16 +10863,12 @@ cdef class FBCStats: raise ValueError("ptr must not be null (0)") cdef FBCStats obj = FBCStats.__new__(FBCStats) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlFBCStats_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating FBCStats") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlFBCStats_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlFBCStats_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -11289,26 +11172,16 @@ cdef class ConfComputeSystemCaps: .. seealso:: `nvmlConfComputeSystemCaps_t` """ cdef: + nvmlConfComputeSystemCaps_t _data nvmlConfComputeSystemCaps_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlConfComputeSystemCaps_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating ConfComputeSystemCaps") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlConfComputeSystemCaps_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.ConfComputeSystemCaps object at {hex(id(self))}>" @@ -11337,14 +11210,20 @@ cdef class ConfComputeSystemCaps: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlConfComputeSystemCaps_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating ConfComputeSystemCaps") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlConfComputeSystemCaps_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlConfComputeSystemCaps_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlConfComputeSystemCaps_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlConfComputeSystemCaps_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -11397,16 +11276,12 @@ cdef class ConfComputeSystemCaps: raise ValueError("ptr must not be null (0)") cdef ConfComputeSystemCaps obj = ConfComputeSystemCaps.__new__(ConfComputeSystemCaps) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlConfComputeSystemCaps_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating ConfComputeSystemCaps") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlConfComputeSystemCaps_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlConfComputeSystemCaps_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -11433,26 +11308,16 @@ cdef class ConfComputeSystemState: .. seealso:: `nvmlConfComputeSystemState_t` """ cdef: + nvmlConfComputeSystemState_t _data nvmlConfComputeSystemState_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlConfComputeSystemState_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating ConfComputeSystemState") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlConfComputeSystemState_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.ConfComputeSystemState object at {hex(id(self))}>" @@ -11481,14 +11346,20 @@ cdef class ConfComputeSystemState: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlConfComputeSystemState_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating ConfComputeSystemState") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlConfComputeSystemState_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlConfComputeSystemState_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlConfComputeSystemState_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlConfComputeSystemState_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -11552,16 +11423,12 @@ cdef class ConfComputeSystemState: raise ValueError("ptr must not be null (0)") cdef ConfComputeSystemState obj = ConfComputeSystemState.__new__(ConfComputeSystemState) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlConfComputeSystemState_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating ConfComputeSystemState") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlConfComputeSystemState_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlConfComputeSystemState_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -11590,26 +11457,16 @@ cdef class SystemConfComputeSettings_v1: .. seealso:: `nvmlSystemConfComputeSettings_v1_t` """ cdef: + nvmlSystemConfComputeSettings_v1_t _data nvmlSystemConfComputeSettings_v1_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlSystemConfComputeSettings_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating SystemConfComputeSettings_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlSystemConfComputeSettings_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.SystemConfComputeSettings_v1 object at {hex(id(self))}>" @@ -11638,14 +11495,20 @@ cdef class SystemConfComputeSettings_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlSystemConfComputeSettings_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating SystemConfComputeSettings_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlSystemConfComputeSettings_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlSystemConfComputeSettings_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlSystemConfComputeSettings_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlSystemConfComputeSettings_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -11731,16 +11594,12 @@ cdef class SystemConfComputeSettings_v1: raise ValueError("ptr must not be null (0)") cdef SystemConfComputeSettings_v1 obj = SystemConfComputeSettings_v1.__new__(SystemConfComputeSettings_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlSystemConfComputeSettings_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating SystemConfComputeSettings_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlSystemConfComputeSettings_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlSystemConfComputeSettings_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -11766,26 +11625,16 @@ cdef class ConfComputeMemSizeInfo: .. seealso:: `nvmlConfComputeMemSizeInfo_t` """ cdef: + nvmlConfComputeMemSizeInfo_t _data nvmlConfComputeMemSizeInfo_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlConfComputeMemSizeInfo_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating ConfComputeMemSizeInfo") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlConfComputeMemSizeInfo_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.ConfComputeMemSizeInfo object at {hex(id(self))}>" @@ -11814,14 +11663,20 @@ cdef class ConfComputeMemSizeInfo: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlConfComputeMemSizeInfo_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating ConfComputeMemSizeInfo") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlConfComputeMemSizeInfo_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlConfComputeMemSizeInfo_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlConfComputeMemSizeInfo_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlConfComputeMemSizeInfo_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -11874,16 +11729,12 @@ cdef class ConfComputeMemSizeInfo: raise ValueError("ptr must not be null (0)") cdef ConfComputeMemSizeInfo obj = ConfComputeMemSizeInfo.__new__(ConfComputeMemSizeInfo) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlConfComputeMemSizeInfo_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating ConfComputeMemSizeInfo") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlConfComputeMemSizeInfo_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlConfComputeMemSizeInfo_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -11911,26 +11762,16 @@ cdef class ConfComputeGpuCertificate: .. seealso:: `nvmlConfComputeGpuCertificate_t` """ cdef: + nvmlConfComputeGpuCertificate_t _data nvmlConfComputeGpuCertificate_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlConfComputeGpuCertificate_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating ConfComputeGpuCertificate") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlConfComputeGpuCertificate_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.ConfComputeGpuCertificate object at {hex(id(self))}>" @@ -11959,14 +11800,20 @@ cdef class ConfComputeGpuCertificate: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlConfComputeGpuCertificate_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating ConfComputeGpuCertificate") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlConfComputeGpuCertificate_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlConfComputeGpuCertificate_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlConfComputeGpuCertificate_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlConfComputeGpuCertificate_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -12041,16 +11888,12 @@ cdef class ConfComputeGpuCertificate: raise ValueError("ptr must not be null (0)") cdef ConfComputeGpuCertificate obj = ConfComputeGpuCertificate.__new__(ConfComputeGpuCertificate) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlConfComputeGpuCertificate_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating ConfComputeGpuCertificate") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlConfComputeGpuCertificate_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlConfComputeGpuCertificate_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -12080,26 +11923,16 @@ cdef class ConfComputeGpuAttestationReport: .. seealso:: `nvmlConfComputeGpuAttestationReport_t` """ cdef: + nvmlConfComputeGpuAttestationReport_t _data nvmlConfComputeGpuAttestationReport_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlConfComputeGpuAttestationReport_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating ConfComputeGpuAttestationReport") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlConfComputeGpuAttestationReport_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.ConfComputeGpuAttestationReport object at {hex(id(self))}>" @@ -12128,14 +11961,20 @@ cdef class ConfComputeGpuAttestationReport: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlConfComputeGpuAttestationReport_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating ConfComputeGpuAttestationReport") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlConfComputeGpuAttestationReport_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlConfComputeGpuAttestationReport_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlConfComputeGpuAttestationReport_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlConfComputeGpuAttestationReport_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -12238,16 +12077,12 @@ cdef class ConfComputeGpuAttestationReport: raise ValueError("ptr must not be null (0)") cdef ConfComputeGpuAttestationReport obj = ConfComputeGpuAttestationReport.__new__(ConfComputeGpuAttestationReport) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlConfComputeGpuAttestationReport_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating ConfComputeGpuAttestationReport") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlConfComputeGpuAttestationReport_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlConfComputeGpuAttestationReport_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -12277,26 +12112,16 @@ cdef class GpuFabricInfo_v2: .. seealso:: `nvmlGpuFabricInfo_v2_t` """ cdef: + nvmlGpuFabricInfo_v2_t _data nvmlGpuFabricInfo_v2_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlGpuFabricInfo_v2_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating GpuFabricInfo_v2") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlGpuFabricInfo_v2_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.GpuFabricInfo_v2 object at {hex(id(self))}>" @@ -12325,14 +12150,20 @@ cdef class GpuFabricInfo_v2: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlGpuFabricInfo_v2_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating GpuFabricInfo_v2") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlGpuFabricInfo_v2_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlGpuFabricInfo_v2_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlGpuFabricInfo_v2_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlGpuFabricInfo_v2_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -12435,16 +12266,12 @@ cdef class GpuFabricInfo_v2: raise ValueError("ptr must not be null (0)") cdef GpuFabricInfo_v2 obj = GpuFabricInfo_v2.__new__(GpuFabricInfo_v2) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlGpuFabricInfo_v2_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating GpuFabricInfo_v2") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlGpuFabricInfo_v2_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlGpuFabricInfo_v2_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -12471,26 +12298,16 @@ cdef class NvlinkSupportedBwModes_v1: .. seealso:: `nvmlNvlinkSupportedBwModes_v1_t` """ cdef: + nvmlNvlinkSupportedBwModes_v1_t _data nvmlNvlinkSupportedBwModes_v1_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlNvlinkSupportedBwModes_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating NvlinkSupportedBwModes_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlNvlinkSupportedBwModes_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.NvlinkSupportedBwModes_v1 object at {hex(id(self))}>" @@ -12519,14 +12336,20 @@ cdef class NvlinkSupportedBwModes_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlNvlinkSupportedBwModes_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating NvlinkSupportedBwModes_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlNvlinkSupportedBwModes_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlNvlinkSupportedBwModes_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlNvlinkSupportedBwModes_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlNvlinkSupportedBwModes_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -12590,16 +12413,12 @@ cdef class NvlinkSupportedBwModes_v1: raise ValueError("ptr must not be null (0)") cdef NvlinkSupportedBwModes_v1 obj = NvlinkSupportedBwModes_v1.__new__(NvlinkSupportedBwModes_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlNvlinkSupportedBwModes_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating NvlinkSupportedBwModes_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlNvlinkSupportedBwModes_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlNvlinkSupportedBwModes_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -12626,26 +12445,16 @@ cdef class NvlinkGetBwMode_v1: .. seealso:: `nvmlNvlinkGetBwMode_v1_t` """ cdef: + nvmlNvlinkGetBwMode_v1_t _data nvmlNvlinkGetBwMode_v1_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlNvlinkGetBwMode_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating NvlinkGetBwMode_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlNvlinkGetBwMode_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.NvlinkGetBwMode_v1 object at {hex(id(self))}>" @@ -12674,14 +12483,20 @@ cdef class NvlinkGetBwMode_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlNvlinkGetBwMode_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating NvlinkGetBwMode_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlNvlinkGetBwMode_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlNvlinkGetBwMode_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlNvlinkGetBwMode_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlNvlinkGetBwMode_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -12745,16 +12560,12 @@ cdef class NvlinkGetBwMode_v1: raise ValueError("ptr must not be null (0)") cdef NvlinkGetBwMode_v1 obj = NvlinkGetBwMode_v1.__new__(NvlinkGetBwMode_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlNvlinkGetBwMode_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating NvlinkGetBwMode_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlNvlinkGetBwMode_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlNvlinkGetBwMode_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -12781,26 +12592,16 @@ cdef class NvlinkSetBwMode_v1: .. seealso:: `nvmlNvlinkSetBwMode_v1_t` """ cdef: + nvmlNvlinkSetBwMode_v1_t _data nvmlNvlinkSetBwMode_v1_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlNvlinkSetBwMode_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating NvlinkSetBwMode_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlNvlinkSetBwMode_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.NvlinkSetBwMode_v1 object at {hex(id(self))}>" @@ -12829,14 +12630,20 @@ cdef class NvlinkSetBwMode_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlNvlinkSetBwMode_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating NvlinkSetBwMode_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlNvlinkSetBwMode_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlNvlinkSetBwMode_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlNvlinkSetBwMode_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlNvlinkSetBwMode_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -12900,16 +12707,12 @@ cdef class NvlinkSetBwMode_v1: raise ValueError("ptr must not be null (0)") cdef NvlinkSetBwMode_v1 obj = NvlinkSetBwMode_v1.__new__(NvlinkSetBwMode_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlNvlinkSetBwMode_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating NvlinkSetBwMode_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlNvlinkSetBwMode_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlNvlinkSetBwMode_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -12936,24 +12739,24 @@ cdef class VgpuVersion: """ cdef: nvmlVgpuVersion_t *_ptr - object _owner - bint _owned + _cyb_PyObject *_owner bint _readonly def __init__(self): self._ptr = _cyb_calloc(1, sizeof(nvmlVgpuVersion_t)) if self._ptr == NULL: raise MemoryError("Error allocating VgpuVersion") - self._owner = None - self._owned = True + self._owner = NULL self._readonly = False def __dealloc__(self): cdef nvmlVgpuVersion_t *ptr - if self._owned and self._ptr != NULL: + if self._owner == NULL and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) + _cyb_Py_CLEAR(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}.VgpuVersion object at {hex(id(self))}>" @@ -12983,14 +12786,24 @@ cdef class VgpuVersion: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlVgpuVersion_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuVersion") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlVgpuVersion_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlVgpuVersion_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlVgpuVersion_t), view.len) + ) + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_CLEAR(self._owner) + self._ptr = _cyb_malloc(sizeof(nvmlVgpuVersion_t)) + if self._ptr == NULL: + raise MemoryError("Error allocating VgpuVersion") + _cyb_memcpy(self._ptr, view.buf, sizeof(nvmlVgpuVersion_t)) + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -13047,12 +12860,11 @@ cdef class VgpuVersion: if obj._ptr == NULL: raise MemoryError("Error allocating VgpuVersion") _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlVgpuVersion_t)) - obj._owner = None - obj._owned = True + obj._owner = NULL else: obj._ptr = ptr - obj._owner = owner - obj._owned = False + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -13086,26 +12898,16 @@ cdef class VgpuMetadata: .. seealso:: `nvmlVgpuMetadata_t` """ cdef: + nvmlVgpuMetadata_t _data nvmlVgpuMetadata_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlVgpuMetadata_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuMetadata") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlVgpuMetadata_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.VgpuMetadata object at {hex(id(self))}>" @@ -13134,14 +12936,20 @@ cdef class VgpuMetadata: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlVgpuMetadata_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuMetadata") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlVgpuMetadata_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlVgpuMetadata_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlVgpuMetadata_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlVgpuMetadata_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -13283,16 +13091,12 @@ cdef class VgpuMetadata: raise ValueError("ptr must not be null (0)") cdef VgpuMetadata obj = VgpuMetadata.__new__(VgpuMetadata) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlVgpuMetadata_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating VgpuMetadata") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlVgpuMetadata_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlVgpuMetadata_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -13318,26 +13122,16 @@ cdef class VgpuPgpuCompatibility: .. seealso:: `nvmlVgpuPgpuCompatibility_t` """ cdef: + nvmlVgpuPgpuCompatibility_t _data nvmlVgpuPgpuCompatibility_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlVgpuPgpuCompatibility_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuPgpuCompatibility") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlVgpuPgpuCompatibility_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.VgpuPgpuCompatibility object at {hex(id(self))}>" @@ -13366,14 +13160,20 @@ cdef class VgpuPgpuCompatibility: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlVgpuPgpuCompatibility_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuPgpuCompatibility") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlVgpuPgpuCompatibility_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlVgpuPgpuCompatibility_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlVgpuPgpuCompatibility_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlVgpuPgpuCompatibility_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -13426,16 +13226,12 @@ cdef class VgpuPgpuCompatibility: raise ValueError("ptr must not be null (0)") cdef VgpuPgpuCompatibility obj = VgpuPgpuCompatibility.__new__(VgpuPgpuCompatibility) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlVgpuPgpuCompatibility_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating VgpuPgpuCompatibility") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlVgpuPgpuCompatibility_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlVgpuPgpuCompatibility_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -13630,26 +13426,16 @@ cdef class GpuInstanceProfileInfo_v3: .. seealso:: `nvmlGpuInstanceProfileInfo_v3_t` """ cdef: + nvmlGpuInstanceProfileInfo_v3_t _data nvmlGpuInstanceProfileInfo_v3_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlGpuInstanceProfileInfo_v3_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating GpuInstanceProfileInfo_v3") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlGpuInstanceProfileInfo_v3_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.GpuInstanceProfileInfo_v3 object at {hex(id(self))}>" @@ -13678,14 +13464,20 @@ cdef class GpuInstanceProfileInfo_v3: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlGpuInstanceProfileInfo_v3_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating GpuInstanceProfileInfo_v3") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlGpuInstanceProfileInfo_v3_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlGpuInstanceProfileInfo_v3_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlGpuInstanceProfileInfo_v3_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlGpuInstanceProfileInfo_v3_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -13863,16 +13655,12 @@ cdef class GpuInstanceProfileInfo_v3: raise ValueError("ptr must not be null (0)") cdef GpuInstanceProfileInfo_v3 obj = GpuInstanceProfileInfo_v3.__new__(GpuInstanceProfileInfo_v3) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlGpuInstanceProfileInfo_v3_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating GpuInstanceProfileInfo_v3") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlGpuInstanceProfileInfo_v3_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlGpuInstanceProfileInfo_v3_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -14065,26 +13853,16 @@ cdef class ComputeInstanceProfileInfo_v2: .. seealso:: `nvmlComputeInstanceProfileInfo_v2_t` """ cdef: + nvmlComputeInstanceProfileInfo_v2_t _data nvmlComputeInstanceProfileInfo_v2_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlComputeInstanceProfileInfo_v2_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating ComputeInstanceProfileInfo_v2") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlComputeInstanceProfileInfo_v2_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.ComputeInstanceProfileInfo_v2 object at {hex(id(self))}>" @@ -14113,14 +13891,20 @@ cdef class ComputeInstanceProfileInfo_v2: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlComputeInstanceProfileInfo_v2_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating ComputeInstanceProfileInfo_v2") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlComputeInstanceProfileInfo_v2_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlComputeInstanceProfileInfo_v2_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlComputeInstanceProfileInfo_v2_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlComputeInstanceProfileInfo_v2_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -14276,16 +14060,12 @@ cdef class ComputeInstanceProfileInfo_v2: raise ValueError("ptr must not be null (0)") cdef ComputeInstanceProfileInfo_v2 obj = ComputeInstanceProfileInfo_v2.__new__(ComputeInstanceProfileInfo_v2) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlComputeInstanceProfileInfo_v2_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating ComputeInstanceProfileInfo_v2") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlComputeInstanceProfileInfo_v2_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlComputeInstanceProfileInfo_v2_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -14321,26 +14101,16 @@ cdef class ComputeInstanceProfileInfo_v3: .. seealso:: `nvmlComputeInstanceProfileInfo_v3_t` """ cdef: + nvmlComputeInstanceProfileInfo_v3_t _data nvmlComputeInstanceProfileInfo_v3_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlComputeInstanceProfileInfo_v3_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating ComputeInstanceProfileInfo_v3") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlComputeInstanceProfileInfo_v3_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.ComputeInstanceProfileInfo_v3 object at {hex(id(self))}>" @@ -14369,14 +14139,20 @@ cdef class ComputeInstanceProfileInfo_v3: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlComputeInstanceProfileInfo_v3_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating ComputeInstanceProfileInfo_v3") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlComputeInstanceProfileInfo_v3_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlComputeInstanceProfileInfo_v3_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlComputeInstanceProfileInfo_v3_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlComputeInstanceProfileInfo_v3_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -14543,16 +14319,12 @@ cdef class ComputeInstanceProfileInfo_v3: raise ValueError("ptr must not be null (0)") cdef ComputeInstanceProfileInfo_v3 obj = ComputeInstanceProfileInfo_v3.__new__(ComputeInstanceProfileInfo_v3) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlComputeInstanceProfileInfo_v3_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating ComputeInstanceProfileInfo_v3") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlComputeInstanceProfileInfo_v3_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlComputeInstanceProfileInfo_v3_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -14578,26 +14350,16 @@ cdef class DeviceAddressingMode_v1: .. seealso:: `nvmlDeviceAddressingMode_v1_t` """ cdef: + nvmlDeviceAddressingMode_v1_t _data nvmlDeviceAddressingMode_v1_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlDeviceAddressingMode_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating DeviceAddressingMode_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlDeviceAddressingMode_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.DeviceAddressingMode_v1 object at {hex(id(self))}>" @@ -14626,14 +14388,20 @@ cdef class DeviceAddressingMode_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlDeviceAddressingMode_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating DeviceAddressingMode_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlDeviceAddressingMode_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlDeviceAddressingMode_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlDeviceAddressingMode_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlDeviceAddressingMode_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -14686,16 +14454,12 @@ cdef class DeviceAddressingMode_v1: raise ValueError("ptr must not be null (0)") cdef DeviceAddressingMode_v1 obj = DeviceAddressingMode_v1.__new__(DeviceAddressingMode_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlDeviceAddressingMode_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating DeviceAddressingMode_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlDeviceAddressingMode_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlDeviceAddressingMode_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -14722,26 +14486,16 @@ cdef class RepairStatus_v1: .. seealso:: `nvmlRepairStatus_v1_t` """ cdef: + nvmlRepairStatus_v1_t _data nvmlRepairStatus_v1_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlRepairStatus_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating RepairStatus_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlRepairStatus_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.RepairStatus_v1 object at {hex(id(self))}>" @@ -14770,14 +14524,20 @@ cdef class RepairStatus_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlRepairStatus_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating RepairStatus_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlRepairStatus_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlRepairStatus_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlRepairStatus_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlRepairStatus_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -14841,16 +14601,12 @@ cdef class RepairStatus_v1: raise ValueError("ptr must not be null (0)") cdef RepairStatus_v1 obj = RepairStatus_v1.__new__(RepairStatus_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlRepairStatus_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating RepairStatus_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlRepairStatus_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlRepairStatus_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -14877,26 +14633,16 @@ cdef class DevicePowerMizerModes_v1: .. seealso:: `nvmlDevicePowerMizerModes_v1_t` """ cdef: + nvmlDevicePowerMizerModes_v1_t _data nvmlDevicePowerMizerModes_v1_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlDevicePowerMizerModes_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating DevicePowerMizerModes_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlDevicePowerMizerModes_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.DevicePowerMizerModes_v1 object at {hex(id(self))}>" @@ -14925,14 +14671,20 @@ cdef class DevicePowerMizerModes_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlDevicePowerMizerModes_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating DevicePowerMizerModes_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlDevicePowerMizerModes_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlDevicePowerMizerModes_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlDevicePowerMizerModes_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlDevicePowerMizerModes_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -14996,16 +14748,12 @@ cdef class DevicePowerMizerModes_v1: raise ValueError("ptr must not be null (0)") cdef DevicePowerMizerModes_v1 obj = DevicePowerMizerModes_v1.__new__(DevicePowerMizerModes_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlDevicePowerMizerModes_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating DevicePowerMizerModes_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlDevicePowerMizerModes_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlDevicePowerMizerModes_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -15254,26 +15002,16 @@ cdef class GpuFabricInfo_v3: .. seealso:: `nvmlGpuFabricInfo_v3_t` """ cdef: + nvmlGpuFabricInfo_v3_t _data nvmlGpuFabricInfo_v3_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlGpuFabricInfo_v3_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating GpuFabricInfo_v3") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlGpuFabricInfo_v3_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.GpuFabricInfo_v3 object at {hex(id(self))}>" @@ -15302,14 +15040,20 @@ cdef class GpuFabricInfo_v3: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlGpuFabricInfo_v3_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating GpuFabricInfo_v3") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlGpuFabricInfo_v3_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlGpuFabricInfo_v3_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlGpuFabricInfo_v3_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlGpuFabricInfo_v3_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -15423,16 +15167,12 @@ cdef class GpuFabricInfo_v3: raise ValueError("ptr must not be null (0)") cdef GpuFabricInfo_v3 obj = GpuFabricInfo_v3.__new__(GpuFabricInfo_v3) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlGpuFabricInfo_v3_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating GpuFabricInfo_v3") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlGpuFabricInfo_v3_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlGpuFabricInfo_v3_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -15458,26 +15198,16 @@ cdef class NvLinkInfo_v1: .. seealso:: `nvmlNvLinkInfo_v1_t` """ cdef: + nvmlNvLinkInfo_v1_t _data nvmlNvLinkInfo_v1_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlNvLinkInfo_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating NvLinkInfo_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlNvLinkInfo_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.NvLinkInfo_v1 object at {hex(id(self))}>" @@ -15506,14 +15236,20 @@ cdef class NvLinkInfo_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlNvLinkInfo_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating NvLinkInfo_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlNvLinkInfo_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlNvLinkInfo_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlNvLinkInfo_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlNvLinkInfo_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -15566,16 +15302,12 @@ cdef class NvLinkInfo_v1: raise ValueError("ptr must not be null (0)") cdef NvLinkInfo_v1 obj = NvLinkInfo_v1.__new__(NvLinkInfo_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlNvLinkInfo_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating NvLinkInfo_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlNvLinkInfo_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlNvLinkInfo_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -15783,24 +15515,24 @@ cdef class PRMCounterInput_v1: """ cdef: nvmlPRMCounterInput_v1_t *_ptr - object _owner - bint _owned + _cyb_PyObject *_owner bint _readonly def __init__(self): self._ptr = _cyb_calloc(1, sizeof(nvmlPRMCounterInput_v1_t)) if self._ptr == NULL: raise MemoryError("Error allocating PRMCounterInput_v1") - self._owner = None - self._owned = True + self._owner = NULL self._readonly = False def __dealloc__(self): cdef nvmlPRMCounterInput_v1_t *ptr - if self._owned and self._ptr != NULL: + if self._owner == NULL and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) + _cyb_Py_CLEAR(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}.PRMCounterInput_v1 object at {hex(id(self))}>" @@ -15830,14 +15562,24 @@ cdef class PRMCounterInput_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlPRMCounterInput_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating PRMCounterInput_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlPRMCounterInput_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlPRMCounterInput_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlPRMCounterInput_v1_t), view.len) + ) + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_CLEAR(self._owner) + self._ptr = _cyb_malloc(sizeof(nvmlPRMCounterInput_v1_t)) + if self._ptr == NULL: + raise MemoryError("Error allocating PRMCounterInput_v1") + _cyb_memcpy(self._ptr, view.buf, sizeof(nvmlPRMCounterInput_v1_t)) + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -15883,12 +15625,11 @@ cdef class PRMCounterInput_v1: if obj._ptr == NULL: raise MemoryError("Error allocating PRMCounterInput_v1") _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlPRMCounterInput_v1_t)) - obj._owner = None - obj._owned = True + obj._owner = NULL else: obj._ptr = ptr - obj._owner = owner - obj._owned = False + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -15916,26 +15657,16 @@ cdef class VgpuSchedulerStateInfo_v2: .. seealso:: `nvmlVgpuSchedulerStateInfo_v2_t` """ cdef: + nvmlVgpuSchedulerStateInfo_v2_t _data nvmlVgpuSchedulerStateInfo_v2_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlVgpuSchedulerStateInfo_v2_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuSchedulerStateInfo_v2") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlVgpuSchedulerStateInfo_v2_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.VgpuSchedulerStateInfo_v2 object at {hex(id(self))}>" @@ -15964,14 +15695,20 @@ cdef class VgpuSchedulerStateInfo_v2: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlVgpuSchedulerStateInfo_v2_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuSchedulerStateInfo_v2") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlVgpuSchedulerStateInfo_v2_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlVgpuSchedulerStateInfo_v2_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlVgpuSchedulerStateInfo_v2_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlVgpuSchedulerStateInfo_v2_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -16046,16 +15783,12 @@ cdef class VgpuSchedulerStateInfo_v2: raise ValueError("ptr must not be null (0)") cdef VgpuSchedulerStateInfo_v2 obj = VgpuSchedulerStateInfo_v2.__new__(VgpuSchedulerStateInfo_v2) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlVgpuSchedulerStateInfo_v2_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating VgpuSchedulerStateInfo_v2") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlVgpuSchedulerStateInfo_v2_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlVgpuSchedulerStateInfo_v2_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -16301,26 +16034,16 @@ cdef class VgpuSchedulerState_v2: .. seealso:: `nvmlVgpuSchedulerState_v2_t` """ cdef: + nvmlVgpuSchedulerState_v2_t _data nvmlVgpuSchedulerState_v2_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlVgpuSchedulerState_v2_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuSchedulerState_v2") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlVgpuSchedulerState_v2_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.VgpuSchedulerState_v2 object at {hex(id(self))}>" @@ -16349,14 +16072,20 @@ cdef class VgpuSchedulerState_v2: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlVgpuSchedulerState_v2_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuSchedulerState_v2") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlVgpuSchedulerState_v2_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlVgpuSchedulerState_v2_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlVgpuSchedulerState_v2_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlVgpuSchedulerState_v2_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -16431,16 +16160,12 @@ cdef class VgpuSchedulerState_v2: raise ValueError("ptr must not be null (0)") cdef VgpuSchedulerState_v2 obj = VgpuSchedulerState_v2.__new__(VgpuSchedulerState_v2) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlVgpuSchedulerState_v2_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating VgpuSchedulerState_v2") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlVgpuSchedulerState_v2_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlVgpuSchedulerState_v2_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -16465,26 +16190,16 @@ cdef class BBXTimeData_v1: .. seealso:: `nvmlBBXTimeData_v1_t` """ cdef: + nvmlBBXTimeData_v1_t _data nvmlBBXTimeData_v1_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlBBXTimeData_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating BBXTimeData_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlBBXTimeData_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.BBXTimeData_v1 object at {hex(id(self))}>" @@ -16513,14 +16228,20 @@ cdef class BBXTimeData_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlBBXTimeData_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating BBXTimeData_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlBBXTimeData_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlBBXTimeData_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlBBXTimeData_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlBBXTimeData_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -16562,16 +16283,12 @@ cdef class BBXTimeData_v1: raise ValueError("ptr must not be null (0)") cdef BBXTimeData_v1 obj = BBXTimeData_v1.__new__(BBXTimeData_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlBBXTimeData_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating BBXTimeData_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlBBXTimeData_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlBBXTimeData_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -16601,26 +16318,16 @@ cdef class RemappedRowsInfo_v2: .. seealso:: `nvmlRemappedRowsInfo_v2_t` """ cdef: + nvmlRemappedRowsInfo_v2_t _data nvmlRemappedRowsInfo_v2_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlRemappedRowsInfo_v2_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating RemappedRowsInfo_v2") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlRemappedRowsInfo_v2_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.RemappedRowsInfo_v2 object at {hex(id(self))}>" @@ -16649,14 +16356,20 @@ cdef class RemappedRowsInfo_v2: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlRemappedRowsInfo_v2_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating RemappedRowsInfo_v2") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlRemappedRowsInfo_v2_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlRemappedRowsInfo_v2_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlRemappedRowsInfo_v2_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlRemappedRowsInfo_v2_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -16753,16 +16466,12 @@ cdef class RemappedRowsInfo_v2: raise ValueError("ptr must not be null (0)") cdef RemappedRowsInfo_v2 obj = RemappedRowsInfo_v2.__new__(RemappedRowsInfo_v2) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlRemappedRowsInfo_v2_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating RemappedRowsInfo_v2") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlRemappedRowsInfo_v2_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlRemappedRowsInfo_v2_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -16796,26 +16505,16 @@ cdef class AccountingStats_v2: .. seealso:: `nvmlAccountingStats_v2_t` """ cdef: + nvmlAccountingStats_v2_t _data nvmlAccountingStats_v2_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlAccountingStats_v2_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating AccountingStats_v2") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlAccountingStats_v2_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.AccountingStats_v2 object at {hex(id(self))}>" @@ -16844,14 +16543,20 @@ cdef class AccountingStats_v2: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlAccountingStats_v2_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating AccountingStats_v2") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlAccountingStats_v2_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlAccountingStats_v2_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlAccountingStats_v2_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlAccountingStats_v2_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -16992,16 +16697,12 @@ cdef class AccountingStats_v2: raise ValueError("ptr must not be null (0)") cdef AccountingStats_v2 obj = AccountingStats_v2.__new__(AccountingStats_v2) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlAccountingStats_v2_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating AccountingStats_v2") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlAccountingStats_v2_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlAccountingStats_v2_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -17029,24 +16730,24 @@ cdef class CPERCursor_v1: """ cdef: nvmlCPERCursor_v1_t *_ptr - object _owner - bint _owned + _cyb_PyObject *_owner bint _readonly def __init__(self): self._ptr = _cyb_calloc(1, sizeof(nvmlCPERCursor_v1_t)) if self._ptr == NULL: raise MemoryError("Error allocating CPERCursor_v1") - self._owner = None - self._owned = True + self._owner = NULL self._readonly = False def __dealloc__(self): cdef nvmlCPERCursor_v1_t *ptr - if self._owned and self._ptr != NULL: + if self._owner == NULL and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) + _cyb_Py_CLEAR(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}.CPERCursor_v1 object at {hex(id(self))}>" @@ -17076,14 +16777,24 @@ cdef class CPERCursor_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlCPERCursor_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating CPERCursor_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlCPERCursor_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlCPERCursor_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlCPERCursor_v1_t), view.len) + ) + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_CLEAR(self._owner) + self._ptr = _cyb_malloc(sizeof(nvmlCPERCursor_v1_t)) + if self._ptr == NULL: + raise MemoryError("Error allocating CPERCursor_v1") + _cyb_memcpy(self._ptr, view.buf, sizeof(nvmlCPERCursor_v1_t)) + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -17155,12 +16866,11 @@ cdef class CPERCursor_v1: if obj._ptr == NULL: raise MemoryError("Error allocating CPERCursor_v1") _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlCPERCursor_v1_t)) - obj._owner = None - obj._owned = True + obj._owner = NULL else: obj._ptr = ptr - obj._owner = owner - obj._owned = False + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -17187,28 +16897,18 @@ cdef class SetMemoryLimits_v1: .. seealso:: `nvmlSetMemoryLimits_v1_t` """ cdef: + nvmlSetMemoryLimits_v1_t _data nvmlSetMemoryLimits_v1_t *_ptr object _owner - bint _owned bint _readonly dict _refs def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlSetMemoryLimits_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating SetMemoryLimits_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False self._refs = {} - def __dealloc__(self): - cdef nvmlSetMemoryLimits_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.SetMemoryLimits_v1 object at {hex(id(self))}>" @@ -17237,14 +16937,20 @@ cdef class SetMemoryLimits_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlSetMemoryLimits_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating SetMemoryLimits_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlSetMemoryLimits_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlSetMemoryLimits_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlSetMemoryLimits_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlSetMemoryLimits_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -17314,16 +17020,12 @@ cdef class SetMemoryLimits_v1: raise ValueError("ptr must not be null (0)") cdef SetMemoryLimits_v1 obj = SetMemoryLimits_v1.__new__(SetMemoryLimits_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlSetMemoryLimits_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating SetMemoryLimits_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlSetMemoryLimits_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlSetMemoryLimits_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly obj._refs = {} return obj @@ -17352,28 +17054,18 @@ cdef class GetMemoryLimits_v1: .. seealso:: `nvmlGetMemoryLimits_v1_t` """ cdef: + nvmlGetMemoryLimits_v1_t _data nvmlGetMemoryLimits_v1_t *_ptr object _owner - bint _owned bint _readonly dict _refs def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlGetMemoryLimits_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating GetMemoryLimits_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False self._refs = {} - def __dealloc__(self): - cdef nvmlGetMemoryLimits_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.GetMemoryLimits_v1 object at {hex(id(self))}>" @@ -17402,14 +17094,20 @@ cdef class GetMemoryLimits_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlGetMemoryLimits_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating GetMemoryLimits_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlGetMemoryLimits_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlGetMemoryLimits_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlGetMemoryLimits_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlGetMemoryLimits_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -17490,16 +17188,12 @@ cdef class GetMemoryLimits_v1: raise ValueError("ptr must not be null (0)") cdef GetMemoryLimits_v1 obj = GetMemoryLimits_v1.__new__(GetMemoryLimits_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlGetMemoryLimits_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating GetMemoryLimits_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlGetMemoryLimits_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlGetMemoryLimits_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly obj._refs = {} return obj @@ -18293,26 +17987,16 @@ cdef class AdaptiveTgpModeInfo_v1: .. seealso:: `nvmlAdaptiveTgpModeInfo_v1_t` """ cdef: + nvmlAdaptiveTgpModeInfo_v1_t _data nvmlAdaptiveTgpModeInfo_v1_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlAdaptiveTgpModeInfo_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating AdaptiveTgpModeInfo_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlAdaptiveTgpModeInfo_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.AdaptiveTgpModeInfo_v1 object at {hex(id(self))}>" @@ -18341,14 +18025,20 @@ cdef class AdaptiveTgpModeInfo_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlAdaptiveTgpModeInfo_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating AdaptiveTgpModeInfo_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlAdaptiveTgpModeInfo_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlAdaptiveTgpModeInfo_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlAdaptiveTgpModeInfo_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlAdaptiveTgpModeInfo_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -18434,16 +18124,12 @@ cdef class AdaptiveTgpModeInfo_v1: raise ValueError("ptr must not be null (0)") cdef AdaptiveTgpModeInfo_v1 obj = AdaptiveTgpModeInfo_v1.__new__(AdaptiveTgpModeInfo_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlAdaptiveTgpModeInfo_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating AdaptiveTgpModeInfo_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlAdaptiveTgpModeInfo_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlAdaptiveTgpModeInfo_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -18468,26 +18154,16 @@ cdef class EventSetGetContextCount_v1: .. seealso:: `nvmlEventSetGetContextCount_v1_t` """ cdef: + nvmlEventSetGetContextCount_v1_t _data nvmlEventSetGetContextCount_v1_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlEventSetGetContextCount_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating EventSetGetContextCount_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlEventSetGetContextCount_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.EventSetGetContextCount_v1 object at {hex(id(self))}>" @@ -18516,14 +18192,20 @@ cdef class EventSetGetContextCount_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlEventSetGetContextCount_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating EventSetGetContextCount_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlEventSetGetContextCount_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlEventSetGetContextCount_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlEventSetGetContextCount_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlEventSetGetContextCount_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -18565,16 +18247,12 @@ cdef class EventSetGetContextCount_v1: raise ValueError("ptr must not be null (0)") cdef EventSetGetContextCount_v1 obj = EventSetGetContextCount_v1.__new__(EventSetGetContextCount_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlEventSetGetContextCount_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating EventSetGetContextCount_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlEventSetGetContextCount_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlEventSetGetContextCount_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -18603,26 +18281,16 @@ cdef class EventSetGetContextInfo_v1: .. seealso:: `nvmlEventSetGetContextInfo_v1_t` """ cdef: + nvmlEventSetGetContextInfo_v1_t _data nvmlEventSetGetContextInfo_v1_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlEventSetGetContextInfo_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating EventSetGetContextInfo_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlEventSetGetContextInfo_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.EventSetGetContextInfo_v1 object at {hex(id(self))}>" @@ -18651,14 +18319,20 @@ cdef class EventSetGetContextInfo_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlEventSetGetContextInfo_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating EventSetGetContextInfo_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlEventSetGetContextInfo_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlEventSetGetContextInfo_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlEventSetGetContextInfo_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlEventSetGetContextInfo_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -18744,16 +18418,12 @@ cdef class EventSetGetContextInfo_v1: raise ValueError("ptr must not be null (0)") cdef EventSetGetContextInfo_v1 obj = EventSetGetContextInfo_v1.__new__(EventSetGetContextInfo_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlEventSetGetContextInfo_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating EventSetGetContextInfo_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlEventSetGetContextInfo_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlEventSetGetContextInfo_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -18779,26 +18449,16 @@ cdef class EventSetGetGpuOperationalEventContextLegacyXid_v1: .. seealso:: `nvmlEventSetGetGpuOperationalEventContextLegacyXid_v1_t` """ cdef: + nvmlEventSetGetGpuOperationalEventContextLegacyXid_v1_t _data nvmlEventSetGetGpuOperationalEventContextLegacyXid_v1_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlEventSetGetGpuOperationalEventContextLegacyXid_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating EventSetGetGpuOperationalEventContextLegacyXid_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlEventSetGetGpuOperationalEventContextLegacyXid_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.EventSetGetGpuOperationalEventContextLegacyXid_v1 object at {hex(id(self))}>" @@ -18827,14 +18487,20 @@ cdef class EventSetGetGpuOperationalEventContextLegacyXid_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlEventSetGetGpuOperationalEventContextLegacyXid_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating EventSetGetGpuOperationalEventContextLegacyXid_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlEventSetGetGpuOperationalEventContextLegacyXid_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlEventSetGetGpuOperationalEventContextLegacyXid_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlEventSetGetGpuOperationalEventContextLegacyXid_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlEventSetGetGpuOperationalEventContextLegacyXid_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -18887,16 +18553,12 @@ cdef class EventSetGetGpuOperationalEventContextLegacyXid_v1: raise ValueError("ptr must not be null (0)") cdef EventSetGetGpuOperationalEventContextLegacyXid_v1 obj = EventSetGetGpuOperationalEventContextLegacyXid_v1.__new__(EventSetGetGpuOperationalEventContextLegacyXid_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlEventSetGetGpuOperationalEventContextLegacyXid_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating EventSetGetGpuOperationalEventContextLegacyXid_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlEventSetGetGpuOperationalEventContextLegacyXid_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlEventSetGetGpuOperationalEventContextLegacyXid_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -18923,24 +18585,24 @@ cdef class GpuFabricClique_v1: """ cdef: nvmlGpuFabricClique_v1_t *_ptr - object _owner - bint _owned + _cyb_PyObject *_owner bint _readonly def __init__(self): self._ptr = _cyb_calloc(1, sizeof(nvmlGpuFabricClique_v1_t)) if self._ptr == NULL: raise MemoryError("Error allocating GpuFabricClique_v1") - self._owner = None - self._owned = True + self._owner = NULL self._readonly = False def __dealloc__(self): cdef nvmlGpuFabricClique_v1_t *ptr - if self._owned and self._ptr != NULL: + if self._owner == NULL and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) + _cyb_Py_CLEAR(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}.GpuFabricClique_v1 object at {hex(id(self))}>" @@ -18970,14 +18632,24 @@ cdef class GpuFabricClique_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlGpuFabricClique_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating GpuFabricClique_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlGpuFabricClique_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlGpuFabricClique_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlGpuFabricClique_v1_t), view.len) + ) + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_CLEAR(self._owner) + self._ptr = _cyb_malloc(sizeof(nvmlGpuFabricClique_v1_t)) + if self._ptr == NULL: + raise MemoryError("Error allocating GpuFabricClique_v1") + _cyb_memcpy(self._ptr, view.buf, sizeof(nvmlGpuFabricClique_v1_t)) + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -19034,12 +18706,11 @@ cdef class GpuFabricClique_v1: if obj._ptr == NULL: raise MemoryError("Error allocating GpuFabricClique_v1") _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlGpuFabricClique_v1_t)) - obj._owner = None - obj._owned = True + obj._owner = NULL else: obj._ptr = ptr - obj._owner = owner - obj._owned = False + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -19066,26 +18737,16 @@ cdef class GpuOperationalEventConfig_v1: .. seealso:: `nvmlGpuOperationalEventConfig_v1_t` """ cdef: + nvmlGpuOperationalEventConfig_v1_t _data nvmlGpuOperationalEventConfig_v1_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlGpuOperationalEventConfig_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating GpuOperationalEventConfig_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlGpuOperationalEventConfig_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.GpuOperationalEventConfig_v1 object at {hex(id(self))}>" @@ -19114,14 +18775,20 @@ cdef class GpuOperationalEventConfig_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlGpuOperationalEventConfig_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating GpuOperationalEventConfig_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlGpuOperationalEventConfig_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlGpuOperationalEventConfig_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlGpuOperationalEventConfig_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlGpuOperationalEventConfig_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -19189,16 +18856,12 @@ cdef class GpuOperationalEventConfig_v1: raise ValueError("ptr must not be null (0)") cdef GpuOperationalEventConfig_v1 obj = GpuOperationalEventConfig_v1.__new__(GpuOperationalEventConfig_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlGpuOperationalEventConfig_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating GpuOperationalEventConfig_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlGpuOperationalEventConfig_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlGpuOperationalEventConfig_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -19247,26 +18910,16 @@ cdef class EventSetWait_v3: .. seealso:: `nvmlEventSetWait_v3_t` """ cdef: + nvmlEventSetWait_v3_t _data nvmlEventSetWait_v3_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlEventSetWait_v3_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating EventSetWait_v3") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlEventSetWait_v3_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.EventSetWait_v3 object at {hex(id(self))}>" @@ -19295,14 +18948,20 @@ cdef class EventSetWait_v3: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlEventSetWait_v3_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating EventSetWait_v3") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlEventSetWait_v3_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlEventSetWait_v3_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlEventSetWait_v3_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlEventSetWait_v3_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -19616,16 +19275,12 @@ cdef class EventSetWait_v3: raise ValueError("ptr must not be null (0)") cdef EventSetWait_v3 obj = EventSetWait_v3.__new__(EventSetWait_v3) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlEventSetWait_v3_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating EventSetWait_v3") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlEventSetWait_v3_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlEventSetWait_v3_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -19652,26 +19307,16 @@ cdef class NvlinkSetBwModeAsync_v1: .. seealso:: `nvmlNvlinkSetBwModeAsync_v1_t` """ cdef: + nvmlNvlinkSetBwModeAsync_v1_t _data nvmlNvlinkSetBwModeAsync_v1_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlNvlinkSetBwModeAsync_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating NvlinkSetBwModeAsync_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlNvlinkSetBwModeAsync_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.NvlinkSetBwModeAsync_v1 object at {hex(id(self))}>" @@ -19700,14 +19345,20 @@ cdef class NvlinkSetBwModeAsync_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlNvlinkSetBwModeAsync_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating NvlinkSetBwModeAsync_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlNvlinkSetBwModeAsync_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlNvlinkSetBwModeAsync_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlNvlinkSetBwModeAsync_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlNvlinkSetBwModeAsync_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -19771,16 +19422,12 @@ cdef class NvlinkSetBwModeAsync_v1: raise ValueError("ptr must not be null (0)") cdef NvlinkSetBwModeAsync_v1 obj = NvlinkSetBwModeAsync_v1.__new__(NvlinkSetBwModeAsync_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlNvlinkSetBwModeAsync_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating NvlinkSetBwModeAsync_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlNvlinkSetBwModeAsync_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlNvlinkSetBwModeAsync_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -20001,24 +19648,24 @@ cdef class EccBankRemapperHistogram_v1: """ cdef: nvmlEccBankRemapperHistogram_v1_t *_ptr - object _owner - bint _owned + _cyb_PyObject *_owner bint _readonly def __init__(self): self._ptr = _cyb_calloc(1, sizeof(nvmlEccBankRemapperHistogram_v1_t)) if self._ptr == NULL: raise MemoryError("Error allocating EccBankRemapperHistogram_v1") - self._owner = None - self._owned = True + self._owner = NULL self._readonly = False def __dealloc__(self): cdef nvmlEccBankRemapperHistogram_v1_t *ptr - if self._owned and self._ptr != NULL: + if self._owner == NULL and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) + _cyb_Py_CLEAR(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}.EccBankRemapperHistogram_v1 object at {hex(id(self))}>" @@ -20048,14 +19695,24 @@ cdef class EccBankRemapperHistogram_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlEccBankRemapperHistogram_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating EccBankRemapperHistogram_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlEccBankRemapperHistogram_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlEccBankRemapperHistogram_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlEccBankRemapperHistogram_v1_t), view.len) + ) + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_CLEAR(self._owner) + self._ptr = _cyb_malloc(sizeof(nvmlEccBankRemapperHistogram_v1_t)) + if self._ptr == NULL: + raise MemoryError("Error allocating EccBankRemapperHistogram_v1") + _cyb_memcpy(self._ptr, view.buf, sizeof(nvmlEccBankRemapperHistogram_v1_t)) + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -20112,12 +19769,11 @@ cdef class EccBankRemapperHistogram_v1: if obj._ptr == NULL: raise MemoryError("Error allocating EccBankRemapperHistogram_v1") _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlEccBankRemapperHistogram_v1_t)) - obj._owner = None - obj._owned = True + obj._owner = NULL else: obj._ptr = ptr - obj._owner = owner - obj._owned = False + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -20143,26 +19799,16 @@ cdef class ExcludedDeviceInfo: .. seealso:: `nvmlExcludedDeviceInfo_t` """ cdef: + nvmlExcludedDeviceInfo_t _data nvmlExcludedDeviceInfo_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlExcludedDeviceInfo_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating ExcludedDeviceInfo") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlExcludedDeviceInfo_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.ExcludedDeviceInfo object at {hex(id(self))}>" @@ -20191,14 +19837,20 @@ cdef class ExcludedDeviceInfo: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlExcludedDeviceInfo_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating ExcludedDeviceInfo") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlExcludedDeviceInfo_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlExcludedDeviceInfo_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlExcludedDeviceInfo_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlExcludedDeviceInfo_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -20260,16 +19912,12 @@ cdef class ExcludedDeviceInfo: raise ValueError("ptr must not be null (0)") cdef ExcludedDeviceInfo obj = ExcludedDeviceInfo.__new__(ExcludedDeviceInfo) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlExcludedDeviceInfo_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating ExcludedDeviceInfo") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlExcludedDeviceInfo_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlExcludedDeviceInfo_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -20297,28 +19945,18 @@ cdef class ProcessDetailList_v1: .. seealso:: `nvmlProcessDetailList_v1_t` """ cdef: + nvmlProcessDetailList_v1_t _data nvmlProcessDetailList_v1_t *_ptr object _owner - bint _owned bint _readonly dict _refs def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlProcessDetailList_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating ProcessDetailList_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False self._refs = {} - def __dealloc__(self): - cdef nvmlProcessDetailList_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.ProcessDetailList_v1 object at {hex(id(self))}>" @@ -20347,14 +19985,20 @@ cdef class ProcessDetailList_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlProcessDetailList_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating ProcessDetailList_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlProcessDetailList_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlProcessDetailList_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlProcessDetailList_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlProcessDetailList_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -20428,16 +20072,12 @@ cdef class ProcessDetailList_v1: raise ValueError("ptr must not be null (0)") cdef ProcessDetailList_v1 obj = ProcessDetailList_v1.__new__(ProcessDetailList_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlProcessDetailList_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating ProcessDetailList_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlProcessDetailList_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlProcessDetailList_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly obj._refs = {} return obj @@ -20464,26 +20104,16 @@ cdef class BridgeChipHierarchy: .. seealso:: `nvmlBridgeChipHierarchy_t` """ cdef: + nvmlBridgeChipHierarchy_t _data nvmlBridgeChipHierarchy_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlBridgeChipHierarchy_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating BridgeChipHierarchy") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlBridgeChipHierarchy_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.BridgeChipHierarchy object at {hex(id(self))}>" @@ -20512,14 +20142,20 @@ cdef class BridgeChipHierarchy: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlBridgeChipHierarchy_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating BridgeChipHierarchy") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlBridgeChipHierarchy_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlBridgeChipHierarchy_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlBridgeChipHierarchy_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlBridgeChipHierarchy_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -20572,16 +20208,12 @@ cdef class BridgeChipHierarchy: raise ValueError("ptr must not be null (0)") cdef BridgeChipHierarchy obj = BridgeChipHierarchy.__new__(BridgeChipHierarchy) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlBridgeChipHierarchy_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating BridgeChipHierarchy") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlBridgeChipHierarchy_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlBridgeChipHierarchy_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -21397,24 +21029,24 @@ cdef class PRMCounterValue_v1: """ cdef: nvmlPRMCounterValue_v1_t *_ptr - object _owner - bint _owned + _cyb_PyObject *_owner bint _readonly def __init__(self): self._ptr = _cyb_calloc(1, sizeof(nvmlPRMCounterValue_v1_t)) if self._ptr == NULL: raise MemoryError("Error allocating PRMCounterValue_v1") - self._owner = None - self._owned = True + self._owner = NULL self._readonly = False def __dealloc__(self): cdef nvmlPRMCounterValue_v1_t *ptr - if self._owned and self._ptr != NULL: + if self._owner == NULL and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) + _cyb_Py_CLEAR(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}.PRMCounterValue_v1 object at {hex(id(self))}>" @@ -21444,14 +21076,24 @@ cdef class PRMCounterValue_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlPRMCounterValue_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating PRMCounterValue_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlPRMCounterValue_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlPRMCounterValue_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlPRMCounterValue_v1_t), view.len) + ) + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_CLEAR(self._owner) + self._ptr = _cyb_malloc(sizeof(nvmlPRMCounterValue_v1_t)) + if self._ptr == NULL: + raise MemoryError("Error allocating PRMCounterValue_v1") + _cyb_memcpy(self._ptr, view.buf, sizeof(nvmlPRMCounterValue_v1_t)) + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -21524,12 +21166,11 @@ cdef class PRMCounterValue_v1: if obj._ptr == NULL: raise MemoryError("Error allocating PRMCounterValue_v1") _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlPRMCounterValue_v1_t)) - obj._owner = None - obj._owned = True + obj._owner = NULL else: obj._ptr = ptr - obj._owner = owner - obj._owned = False + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -21555,26 +21196,16 @@ cdef class GpuThermalSettings: .. seealso:: `nvmlGpuThermalSettings_t` """ cdef: + nvmlGpuThermalSettings_t _data nvmlGpuThermalSettings_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlGpuThermalSettings_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating GpuThermalSettings") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlGpuThermalSettings_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.GpuThermalSettings object at {hex(id(self))}>" @@ -21603,14 +21234,20 @@ cdef class GpuThermalSettings: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlGpuThermalSettings_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating GpuThermalSettings") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlGpuThermalSettings_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlGpuThermalSettings_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlGpuThermalSettings_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlGpuThermalSettings_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -21671,16 +21308,12 @@ cdef class GpuThermalSettings: raise ValueError("ptr must not be null (0)") cdef GpuThermalSettings obj = GpuThermalSettings.__new__(GpuThermalSettings) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlGpuThermalSettings_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating GpuThermalSettings") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlGpuThermalSettings_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlGpuThermalSettings_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -21707,26 +21340,16 @@ cdef class ClkMonStatus: .. seealso:: `nvmlClkMonStatus_t` """ cdef: + nvmlClkMonStatus_t _data nvmlClkMonStatus_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlClkMonStatus_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating ClkMonStatus") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlClkMonStatus_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.ClkMonStatus object at {hex(id(self))}>" @@ -21755,14 +21378,20 @@ cdef class ClkMonStatus: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlClkMonStatus_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating ClkMonStatus") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlClkMonStatus_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlClkMonStatus_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlClkMonStatus_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlClkMonStatus_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -21826,16 +21455,12 @@ cdef class ClkMonStatus: raise ValueError("ptr must not be null (0)") cdef ClkMonStatus obj = ClkMonStatus.__new__(ClkMonStatus) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlClkMonStatus_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating ClkMonStatus") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlClkMonStatus_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlClkMonStatus_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -21863,28 +21488,18 @@ cdef class ProcessesUtilizationInfo_v1: .. seealso:: `nvmlProcessesUtilizationInfo_v1_t` """ cdef: + nvmlProcessesUtilizationInfo_v1_t _data nvmlProcessesUtilizationInfo_v1_t *_ptr object _owner - bint _owned bint _readonly dict _refs def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlProcessesUtilizationInfo_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating ProcessesUtilizationInfo_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False self._refs = {} - def __dealloc__(self): - cdef nvmlProcessesUtilizationInfo_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.ProcessesUtilizationInfo_v1 object at {hex(id(self))}>" @@ -21913,14 +21528,20 @@ cdef class ProcessesUtilizationInfo_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlProcessesUtilizationInfo_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating ProcessesUtilizationInfo_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlProcessesUtilizationInfo_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlProcessesUtilizationInfo_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlProcessesUtilizationInfo_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlProcessesUtilizationInfo_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -21994,16 +21615,12 @@ cdef class ProcessesUtilizationInfo_v1: raise ValueError("ptr must not be null (0)") cdef ProcessesUtilizationInfo_v1 obj = ProcessesUtilizationInfo_v1.__new__(ProcessesUtilizationInfo_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlProcessesUtilizationInfo_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating ProcessesUtilizationInfo_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlProcessesUtilizationInfo_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlProcessesUtilizationInfo_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly obj._refs = {} return obj @@ -22030,26 +21647,16 @@ cdef class GpuDynamicPstatesInfo: .. seealso:: `nvmlGpuDynamicPstatesInfo_t` """ cdef: + nvmlGpuDynamicPstatesInfo_t _data nvmlGpuDynamicPstatesInfo_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlGpuDynamicPstatesInfo_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating GpuDynamicPstatesInfo") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlGpuDynamicPstatesInfo_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.GpuDynamicPstatesInfo object at {hex(id(self))}>" @@ -22078,14 +21685,20 @@ cdef class GpuDynamicPstatesInfo: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlGpuDynamicPstatesInfo_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating GpuDynamicPstatesInfo") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlGpuDynamicPstatesInfo_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlGpuDynamicPstatesInfo_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlGpuDynamicPstatesInfo_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlGpuDynamicPstatesInfo_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -22146,16 +21759,12 @@ cdef class GpuDynamicPstatesInfo: raise ValueError("ptr must not be null (0)") cdef GpuDynamicPstatesInfo obj = GpuDynamicPstatesInfo.__new__(GpuDynamicPstatesInfo) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlGpuDynamicPstatesInfo_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating GpuDynamicPstatesInfo") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlGpuDynamicPstatesInfo_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlGpuDynamicPstatesInfo_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -22183,28 +21792,18 @@ cdef class VgpuProcessesUtilizationInfo_v1: .. seealso:: `nvmlVgpuProcessesUtilizationInfo_v1_t` """ cdef: + nvmlVgpuProcessesUtilizationInfo_v1_t _data nvmlVgpuProcessesUtilizationInfo_v1_t *_ptr object _owner - bint _owned bint _readonly dict _refs def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlVgpuProcessesUtilizationInfo_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuProcessesUtilizationInfo_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False self._refs = {} - def __dealloc__(self): - cdef nvmlVgpuProcessesUtilizationInfo_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.VgpuProcessesUtilizationInfo_v1 object at {hex(id(self))}>" @@ -22233,14 +21832,20 @@ cdef class VgpuProcessesUtilizationInfo_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlVgpuProcessesUtilizationInfo_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuProcessesUtilizationInfo_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlVgpuProcessesUtilizationInfo_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlVgpuProcessesUtilizationInfo_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlVgpuProcessesUtilizationInfo_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlVgpuProcessesUtilizationInfo_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -22314,16 +21919,12 @@ cdef class VgpuProcessesUtilizationInfo_v1: raise ValueError("ptr must not be null (0)") cdef VgpuProcessesUtilizationInfo_v1 obj = VgpuProcessesUtilizationInfo_v1.__new__(VgpuProcessesUtilizationInfo_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlVgpuProcessesUtilizationInfo_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating VgpuProcessesUtilizationInfo_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlVgpuProcessesUtilizationInfo_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlVgpuProcessesUtilizationInfo_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly obj._refs = {} return obj @@ -22351,24 +21952,24 @@ cdef class VgpuSchedulerParams: """ cdef: nvmlVgpuSchedulerParams_t *_ptr - object _owner - bint _owned + _cyb_PyObject *_owner bint _readonly def __init__(self): self._ptr = _cyb_calloc(1, sizeof(nvmlVgpuSchedulerParams_t)) if self._ptr == NULL: raise MemoryError("Error allocating VgpuSchedulerParams") - self._owner = None - self._owned = True + self._owner = NULL self._readonly = False def __dealloc__(self): cdef nvmlVgpuSchedulerParams_t *ptr - if self._owned and self._ptr != NULL: + if self._owner == NULL and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) + _cyb_Py_CLEAR(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}.VgpuSchedulerParams object at {hex(id(self))}>" @@ -22398,14 +21999,24 @@ cdef class VgpuSchedulerParams: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlVgpuSchedulerParams_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuSchedulerParams") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlVgpuSchedulerParams_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlVgpuSchedulerParams_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlVgpuSchedulerParams_t), view.len) + ) + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_CLEAR(self._owner) + self._ptr = _cyb_malloc(sizeof(nvmlVgpuSchedulerParams_t)) + if self._ptr == NULL: + raise MemoryError("Error allocating VgpuSchedulerParams") + _cyb_memcpy(self._ptr, view.buf, sizeof(nvmlVgpuSchedulerParams_t)) + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -22472,12 +22083,11 @@ cdef class VgpuSchedulerParams: if obj._ptr == NULL: raise MemoryError("Error allocating VgpuSchedulerParams") _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlVgpuSchedulerParams_t)) - obj._owner = None - obj._owned = True + obj._owner = NULL else: obj._ptr = ptr - obj._owner = owner - obj._owned = False + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -22504,24 +22114,24 @@ cdef class VgpuSchedulerSetParams: """ cdef: nvmlVgpuSchedulerSetParams_t *_ptr - object _owner - bint _owned + _cyb_PyObject *_owner bint _readonly def __init__(self): self._ptr = _cyb_calloc(1, sizeof(nvmlVgpuSchedulerSetParams_t)) if self._ptr == NULL: raise MemoryError("Error allocating VgpuSchedulerSetParams") - self._owner = None - self._owned = True + self._owner = NULL self._readonly = False def __dealloc__(self): cdef nvmlVgpuSchedulerSetParams_t *ptr - if self._owned and self._ptr != NULL: + if self._owner == NULL and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) + _cyb_Py_CLEAR(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}.VgpuSchedulerSetParams object at {hex(id(self))}>" @@ -22551,14 +22161,24 @@ cdef class VgpuSchedulerSetParams: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlVgpuSchedulerSetParams_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuSchedulerSetParams") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlVgpuSchedulerSetParams_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlVgpuSchedulerSetParams_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlVgpuSchedulerSetParams_t), view.len) + ) + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_CLEAR(self._owner) + self._ptr = _cyb_malloc(sizeof(nvmlVgpuSchedulerSetParams_t)) + if self._ptr == NULL: + raise MemoryError("Error allocating VgpuSchedulerSetParams") + _cyb_memcpy(self._ptr, view.buf, sizeof(nvmlVgpuSchedulerSetParams_t)) + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -22625,12 +22245,11 @@ cdef class VgpuSchedulerSetParams: if obj._ptr == NULL: raise MemoryError("Error allocating VgpuSchedulerSetParams") _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlVgpuSchedulerSetParams_t)) - obj._owner = None - obj._owned = True + obj._owner = NULL else: obj._ptr = ptr - obj._owner = owner - obj._owned = False + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -22657,26 +22276,16 @@ cdef class VgpuLicenseInfo: .. seealso:: `nvmlVgpuLicenseInfo_t` """ cdef: + nvmlVgpuLicenseInfo_t _data nvmlVgpuLicenseInfo_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlVgpuLicenseInfo_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuLicenseInfo") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlVgpuLicenseInfo_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.VgpuLicenseInfo object at {hex(id(self))}>" @@ -22705,14 +22314,20 @@ cdef class VgpuLicenseInfo: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlVgpuLicenseInfo_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuLicenseInfo") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlVgpuLicenseInfo_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlVgpuLicenseInfo_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlVgpuLicenseInfo_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlVgpuLicenseInfo_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -22781,16 +22396,12 @@ cdef class VgpuLicenseInfo: raise ValueError("ptr must not be null (0)") cdef VgpuLicenseInfo obj = VgpuLicenseInfo.__new__(VgpuLicenseInfo) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlVgpuLicenseInfo_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating VgpuLicenseInfo") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlVgpuLicenseInfo_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlVgpuLicenseInfo_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -23016,26 +22627,16 @@ cdef class UnitFanSpeeds: .. seealso:: `nvmlUnitFanSpeeds_t` """ cdef: + nvmlUnitFanSpeeds_t _data nvmlUnitFanSpeeds_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlUnitFanSpeeds_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating UnitFanSpeeds") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlUnitFanSpeeds_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.UnitFanSpeeds object at {hex(id(self))}>" @@ -23064,14 +22665,20 @@ cdef class UnitFanSpeeds: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlUnitFanSpeeds_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating UnitFanSpeeds") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlUnitFanSpeeds_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlUnitFanSpeeds_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlUnitFanSpeeds_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlUnitFanSpeeds_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -23132,16 +22739,12 @@ cdef class UnitFanSpeeds: raise ValueError("ptr must not be null (0)") cdef UnitFanSpeeds obj = UnitFanSpeeds.__new__(UnitFanSpeeds) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlUnitFanSpeeds_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating UnitFanSpeeds") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlUnitFanSpeeds_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlUnitFanSpeeds_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -23173,26 +22776,16 @@ cdef class VgpuPgpuMetadata: .. seealso:: `nvmlVgpuPgpuMetadata_t` """ cdef: + nvmlVgpuPgpuMetadata_t _data nvmlVgpuPgpuMetadata_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlVgpuPgpuMetadata_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuPgpuMetadata") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlVgpuPgpuMetadata_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.VgpuPgpuMetadata object at {hex(id(self))}>" @@ -23221,14 +22814,20 @@ cdef class VgpuPgpuMetadata: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlVgpuPgpuMetadata_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuPgpuMetadata") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlVgpuPgpuMetadata_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlVgpuPgpuMetadata_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlVgpuPgpuMetadata_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlVgpuPgpuMetadata_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -23349,16 +22948,12 @@ cdef class VgpuPgpuMetadata: raise ValueError("ptr must not be null (0)") cdef VgpuPgpuMetadata obj = VgpuPgpuMetadata.__new__(VgpuPgpuMetadata) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlVgpuPgpuMetadata_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating VgpuPgpuMetadata") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlVgpuPgpuMetadata_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlVgpuPgpuMetadata_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -23386,26 +22981,16 @@ cdef class GpuInstanceInfo: .. seealso:: `nvmlGpuInstanceInfo_t` """ cdef: + nvmlGpuInstanceInfo_t _data nvmlGpuInstanceInfo_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlGpuInstanceInfo_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating GpuInstanceInfo") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlGpuInstanceInfo_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.GpuInstanceInfo object at {hex(id(self))}>" @@ -23434,14 +23019,20 @@ cdef class GpuInstanceInfo: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlGpuInstanceInfo_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating GpuInstanceInfo") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlGpuInstanceInfo_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlGpuInstanceInfo_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlGpuInstanceInfo_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlGpuInstanceInfo_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -23522,16 +23113,12 @@ cdef class GpuInstanceInfo: raise ValueError("ptr must not be null (0)") cdef GpuInstanceInfo obj = GpuInstanceInfo.__new__(GpuInstanceInfo) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlGpuInstanceInfo_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating GpuInstanceInfo") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlGpuInstanceInfo_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlGpuInstanceInfo_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -23560,26 +23147,16 @@ cdef class ComputeInstanceInfo: .. seealso:: `nvmlComputeInstanceInfo_t` """ cdef: + nvmlComputeInstanceInfo_t _data nvmlComputeInstanceInfo_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlComputeInstanceInfo_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating ComputeInstanceInfo") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlComputeInstanceInfo_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.ComputeInstanceInfo object at {hex(id(self))}>" @@ -23608,14 +23185,20 @@ cdef class ComputeInstanceInfo: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlComputeInstanceInfo_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating ComputeInstanceInfo") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlComputeInstanceInfo_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlComputeInstanceInfo_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlComputeInstanceInfo_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlComputeInstanceInfo_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -23707,16 +23290,12 @@ cdef class ComputeInstanceInfo: raise ValueError("ptr must not be null (0)") cdef ComputeInstanceInfo obj = ComputeInstanceInfo.__new__(ComputeInstanceInfo) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlComputeInstanceInfo_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating ComputeInstanceInfo") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlComputeInstanceInfo_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlComputeInstanceInfo_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -23743,28 +23322,18 @@ cdef class EccSramUniqueUncorrectedErrorCounts_v1: .. seealso:: `nvmlEccSramUniqueUncorrectedErrorCounts_v1_t` """ cdef: + nvmlEccSramUniqueUncorrectedErrorCounts_v1_t _data nvmlEccSramUniqueUncorrectedErrorCounts_v1_t *_ptr object _owner - bint _owned bint _readonly dict _refs def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlEccSramUniqueUncorrectedErrorCounts_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating EccSramUniqueUncorrectedErrorCounts_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False self._refs = {} - def __dealloc__(self): - cdef nvmlEccSramUniqueUncorrectedErrorCounts_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.EccSramUniqueUncorrectedErrorCounts_v1 object at {hex(id(self))}>" @@ -23793,14 +23362,20 @@ cdef class EccSramUniqueUncorrectedErrorCounts_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlEccSramUniqueUncorrectedErrorCounts_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating EccSramUniqueUncorrectedErrorCounts_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlEccSramUniqueUncorrectedErrorCounts_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlEccSramUniqueUncorrectedErrorCounts_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlEccSramUniqueUncorrectedErrorCounts_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlEccSramUniqueUncorrectedErrorCounts_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -23863,16 +23438,12 @@ cdef class EccSramUniqueUncorrectedErrorCounts_v1: raise ValueError("ptr must not be null (0)") cdef EccSramUniqueUncorrectedErrorCounts_v1 obj = EccSramUniqueUncorrectedErrorCounts_v1.__new__(EccSramUniqueUncorrectedErrorCounts_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlEccSramUniqueUncorrectedErrorCounts_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating EccSramUniqueUncorrectedErrorCounts_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlEccSramUniqueUncorrectedErrorCounts_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlEccSramUniqueUncorrectedErrorCounts_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly obj._refs = {} return obj @@ -23900,24 +23471,24 @@ cdef class NvlinkFirmwareInfo: """ cdef: nvmlNvlinkFirmwareInfo_t *_ptr - object _owner - bint _owned + _cyb_PyObject *_owner bint _readonly def __init__(self): self._ptr = _cyb_calloc(1, sizeof(nvmlNvlinkFirmwareInfo_t)) if self._ptr == NULL: raise MemoryError("Error allocating NvlinkFirmwareInfo") - self._owner = None - self._owned = True + self._owner = NULL self._readonly = False def __dealloc__(self): cdef nvmlNvlinkFirmwareInfo_t *ptr - if self._owned and self._ptr != NULL: + if self._owner == NULL and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) + _cyb_Py_CLEAR(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}.NvlinkFirmwareInfo object at {hex(id(self))}>" @@ -23947,14 +23518,24 @@ cdef class NvlinkFirmwareInfo: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlNvlinkFirmwareInfo_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating NvlinkFirmwareInfo") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlNvlinkFirmwareInfo_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlNvlinkFirmwareInfo_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlNvlinkFirmwareInfo_t), view.len) + ) + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_CLEAR(self._owner) + self._ptr = _cyb_malloc(sizeof(nvmlNvlinkFirmwareInfo_t)) + if self._ptr == NULL: + raise MemoryError("Error allocating NvlinkFirmwareInfo") + _cyb_memcpy(self._ptr, view.buf, sizeof(nvmlNvlinkFirmwareInfo_t)) + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -24019,12 +23600,11 @@ cdef class NvlinkFirmwareInfo: if obj._ptr == NULL: raise MemoryError("Error allocating NvlinkFirmwareInfo") _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlNvlinkFirmwareInfo_t)) - obj._owner = None - obj._owned = True + obj._owner = NULL else: obj._ptr = ptr - obj._owner = owner - obj._owned = False + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -24054,26 +23634,16 @@ cdef class VgpuSchedulerLogInfo_v2: .. seealso:: `nvmlVgpuSchedulerLogInfo_v2_t` """ cdef: + nvmlVgpuSchedulerLogInfo_v2_t _data nvmlVgpuSchedulerLogInfo_v2_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlVgpuSchedulerLogInfo_v2_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuSchedulerLogInfo_v2") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlVgpuSchedulerLogInfo_v2_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.VgpuSchedulerLogInfo_v2 object at {hex(id(self))}>" @@ -24102,14 +23672,20 @@ cdef class VgpuSchedulerLogInfo_v2: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlVgpuSchedulerLogInfo_v2_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuSchedulerLogInfo_v2") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlVgpuSchedulerLogInfo_v2_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlVgpuSchedulerLogInfo_v2_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlVgpuSchedulerLogInfo_v2_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlVgpuSchedulerLogInfo_v2_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -24214,16 +23790,12 @@ cdef class VgpuSchedulerLogInfo_v2: raise ValueError("ptr must not be null (0)") cdef VgpuSchedulerLogInfo_v2 obj = VgpuSchedulerLogInfo_v2.__new__(VgpuSchedulerLogInfo_v2) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlVgpuSchedulerLogInfo_v2_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating VgpuSchedulerLogInfo_v2") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlVgpuSchedulerLogInfo_v2_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlVgpuSchedulerLogInfo_v2_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -24250,26 +23822,16 @@ cdef class GetCPER_v1: .. seealso:: `nvmlGetCPER_v1_t` """ cdef: + nvmlGetCPER_v1_t _data nvmlGetCPER_v1_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlGetCPER_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating GetCPER_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlGetCPER_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.GetCPER_v1 object at {hex(id(self))}>" @@ -24298,14 +23860,20 @@ cdef class GetCPER_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlGetCPER_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating GetCPER_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlGetCPER_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlGetCPER_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlGetCPER_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlGetCPER_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -24374,16 +23942,12 @@ cdef class GetCPER_v1: raise ValueError("ptr must not be null (0)") cdef GetCPER_v1 obj = GetCPER_v1.__new__(GetCPER_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlGetCPER_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating GetCPER_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlGetCPER_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlGetCPER_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -24760,26 +24324,16 @@ cdef class GpuFabricInfo_v4: .. seealso:: `nvmlGpuFabricInfo_v4_t` """ cdef: + nvmlGpuFabricInfo_v4_t _data nvmlGpuFabricInfo_v4_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlGpuFabricInfo_v4_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating GpuFabricInfo_v4") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlGpuFabricInfo_v4_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.GpuFabricInfo_v4 object at {hex(id(self))}>" @@ -24808,14 +24362,20 @@ cdef class GpuFabricInfo_v4: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlGpuFabricInfo_v4_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating GpuFabricInfo_v4") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlGpuFabricInfo_v4_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlGpuFabricInfo_v4_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlGpuFabricInfo_v4_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlGpuFabricInfo_v4_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -24936,16 +24496,12 @@ cdef class GpuFabricInfo_v4: raise ValueError("ptr must not be null (0)") cdef GpuFabricInfo_v4 obj = GpuFabricInfo_v4.__new__(GpuFabricInfo_v4) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlGpuFabricInfo_v4_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating GpuFabricInfo_v4") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlGpuFabricInfo_v4_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlGpuFabricInfo_v4_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -24971,28 +24527,18 @@ cdef class NvlinkTelemetrySamples_v1: .. seealso:: `nvmlNvlinkTelemetrySamples_v1_t` """ cdef: + nvmlNvlinkTelemetrySamples_v1_t _data nvmlNvlinkTelemetrySamples_v1_t *_ptr object _owner - bint _owned bint _readonly dict _refs def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlNvlinkTelemetrySamples_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating NvlinkTelemetrySamples_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False self._refs = {} - def __dealloc__(self): - cdef nvmlNvlinkTelemetrySamples_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.NvlinkTelemetrySamples_v1 object at {hex(id(self))}>" @@ -25021,14 +24567,20 @@ cdef class NvlinkTelemetrySamples_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlNvlinkTelemetrySamples_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating NvlinkTelemetrySamples_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlNvlinkTelemetrySamples_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlNvlinkTelemetrySamples_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlNvlinkTelemetrySamples_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlNvlinkTelemetrySamples_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -25080,16 +24632,12 @@ cdef class NvlinkTelemetrySamples_v1: raise ValueError("ptr must not be null (0)") cdef NvlinkTelemetrySamples_v1 obj = NvlinkTelemetrySamples_v1.__new__(NvlinkTelemetrySamples_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlNvlinkTelemetrySamples_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating NvlinkTelemetrySamples_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlNvlinkTelemetrySamples_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlNvlinkTelemetrySamples_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly obj._refs = {} return obj @@ -25118,26 +24666,16 @@ cdef class EccBankRemapperStatus_v1: .. seealso:: `nvmlEccBankRemapperStatus_v1_t` """ cdef: + nvmlEccBankRemapperStatus_v1_t _data nvmlEccBankRemapperStatus_v1_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlEccBankRemapperStatus_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating EccBankRemapperStatus_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlEccBankRemapperStatus_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.EccBankRemapperStatus_v1 object at {hex(id(self))}>" @@ -25166,14 +24704,20 @@ cdef class EccBankRemapperStatus_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlEccBankRemapperStatus_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating EccBankRemapperStatus_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlEccBankRemapperStatus_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlEccBankRemapperStatus_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlEccBankRemapperStatus_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlEccBankRemapperStatus_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -25253,16 +24797,12 @@ cdef class EccBankRemapperStatus_v1: raise ValueError("ptr must not be null (0)") cdef EccBankRemapperStatus_v1 obj = EccBankRemapperStatus_v1.__new__(EccBankRemapperStatus_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlEccBankRemapperStatus_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating EccBankRemapperStatus_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlEccBankRemapperStatus_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlEccBankRemapperStatus_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -25291,28 +24831,18 @@ cdef class VgpuInstancesUtilizationInfo_v1: .. seealso:: `nvmlVgpuInstancesUtilizationInfo_v1_t` """ cdef: + nvmlVgpuInstancesUtilizationInfo_v1_t _data nvmlVgpuInstancesUtilizationInfo_v1_t *_ptr object _owner - bint _owned bint _readonly dict _refs def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlVgpuInstancesUtilizationInfo_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuInstancesUtilizationInfo_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False self._refs = {} - def __dealloc__(self): - cdef nvmlVgpuInstancesUtilizationInfo_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.VgpuInstancesUtilizationInfo_v1 object at {hex(id(self))}>" @@ -25341,14 +24871,20 @@ cdef class VgpuInstancesUtilizationInfo_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlVgpuInstancesUtilizationInfo_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuInstancesUtilizationInfo_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlVgpuInstancesUtilizationInfo_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlVgpuInstancesUtilizationInfo_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlVgpuInstancesUtilizationInfo_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlVgpuInstancesUtilizationInfo_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -25433,16 +24969,12 @@ cdef class VgpuInstancesUtilizationInfo_v1: raise ValueError("ptr must not be null (0)") cdef VgpuInstancesUtilizationInfo_v1 obj = VgpuInstancesUtilizationInfo_v1.__new__(VgpuInstancesUtilizationInfo_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlVgpuInstancesUtilizationInfo_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating VgpuInstancesUtilizationInfo_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlVgpuInstancesUtilizationInfo_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlVgpuInstancesUtilizationInfo_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly obj._refs = {} return obj @@ -25639,26 +25171,16 @@ cdef class VgpuSchedulerLog: .. seealso:: `nvmlVgpuSchedulerLog_t` """ cdef: + nvmlVgpuSchedulerLog_t _data nvmlVgpuSchedulerLog_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlVgpuSchedulerLog_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuSchedulerLog") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlVgpuSchedulerLog_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.VgpuSchedulerLog object at {hex(id(self))}>" @@ -25687,14 +25209,20 @@ cdef class VgpuSchedulerLog: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlVgpuSchedulerLog_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuSchedulerLog") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlVgpuSchedulerLog_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlVgpuSchedulerLog_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlVgpuSchedulerLog_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlVgpuSchedulerLog_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -25804,16 +25332,12 @@ cdef class VgpuSchedulerLog: raise ValueError("ptr must not be null (0)") cdef VgpuSchedulerLog obj = VgpuSchedulerLog.__new__(VgpuSchedulerLog) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlVgpuSchedulerLog_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating VgpuSchedulerLog") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlVgpuSchedulerLog_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlVgpuSchedulerLog_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -25840,26 +25364,16 @@ cdef class VgpuSchedulerGetState: .. seealso:: `nvmlVgpuSchedulerGetState_t` """ cdef: + nvmlVgpuSchedulerGetState_t _data nvmlVgpuSchedulerGetState_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlVgpuSchedulerGetState_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuSchedulerGetState") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlVgpuSchedulerGetState_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.VgpuSchedulerGetState object at {hex(id(self))}>" @@ -25888,14 +25402,20 @@ cdef class VgpuSchedulerGetState: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlVgpuSchedulerGetState_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuSchedulerGetState") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlVgpuSchedulerGetState_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlVgpuSchedulerGetState_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlVgpuSchedulerGetState_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlVgpuSchedulerGetState_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -25964,16 +25484,12 @@ cdef class VgpuSchedulerGetState: raise ValueError("ptr must not be null (0)") cdef VgpuSchedulerGetState obj = VgpuSchedulerGetState.__new__(VgpuSchedulerGetState) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlVgpuSchedulerGetState_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating VgpuSchedulerGetState") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlVgpuSchedulerGetState_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlVgpuSchedulerGetState_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -26002,26 +25518,16 @@ cdef class VgpuSchedulerStateInfo_v1: .. seealso:: `nvmlVgpuSchedulerStateInfo_v1_t` """ cdef: + nvmlVgpuSchedulerStateInfo_v1_t _data nvmlVgpuSchedulerStateInfo_v1_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlVgpuSchedulerStateInfo_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuSchedulerStateInfo_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlVgpuSchedulerStateInfo_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.VgpuSchedulerStateInfo_v1 object at {hex(id(self))}>" @@ -26050,14 +25556,20 @@ cdef class VgpuSchedulerStateInfo_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlVgpuSchedulerStateInfo_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuSchedulerStateInfo_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlVgpuSchedulerStateInfo_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlVgpuSchedulerStateInfo_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlVgpuSchedulerStateInfo_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlVgpuSchedulerStateInfo_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -26148,16 +25660,12 @@ cdef class VgpuSchedulerStateInfo_v1: raise ValueError("ptr must not be null (0)") cdef VgpuSchedulerStateInfo_v1 obj = VgpuSchedulerStateInfo_v1.__new__(VgpuSchedulerStateInfo_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlVgpuSchedulerStateInfo_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating VgpuSchedulerStateInfo_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlVgpuSchedulerStateInfo_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlVgpuSchedulerStateInfo_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -26188,26 +25696,16 @@ cdef class VgpuSchedulerLogInfo_v1: .. seealso:: `nvmlVgpuSchedulerLogInfo_v1_t` """ cdef: + nvmlVgpuSchedulerLogInfo_v1_t _data nvmlVgpuSchedulerLogInfo_v1_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlVgpuSchedulerLogInfo_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuSchedulerLogInfo_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlVgpuSchedulerLogInfo_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.VgpuSchedulerLogInfo_v1 object at {hex(id(self))}>" @@ -26236,14 +25734,20 @@ cdef class VgpuSchedulerLogInfo_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlVgpuSchedulerLogInfo_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuSchedulerLogInfo_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlVgpuSchedulerLogInfo_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlVgpuSchedulerLogInfo_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlVgpuSchedulerLogInfo_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlVgpuSchedulerLogInfo_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -26364,16 +25868,12 @@ cdef class VgpuSchedulerLogInfo_v1: raise ValueError("ptr must not be null (0)") cdef VgpuSchedulerLogInfo_v1 obj = VgpuSchedulerLogInfo_v1.__new__(VgpuSchedulerLogInfo_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlVgpuSchedulerLogInfo_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating VgpuSchedulerLogInfo_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlVgpuSchedulerLogInfo_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlVgpuSchedulerLogInfo_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -26402,26 +25902,16 @@ cdef class VgpuSchedulerState_v1: .. seealso:: `nvmlVgpuSchedulerState_v1_t` """ cdef: + nvmlVgpuSchedulerState_v1_t _data nvmlVgpuSchedulerState_v1_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlVgpuSchedulerState_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuSchedulerState_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlVgpuSchedulerState_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.VgpuSchedulerState_v1 object at {hex(id(self))}>" @@ -26450,14 +25940,20 @@ cdef class VgpuSchedulerState_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlVgpuSchedulerState_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating VgpuSchedulerState_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlVgpuSchedulerState_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlVgpuSchedulerState_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlVgpuSchedulerState_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlVgpuSchedulerState_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -26548,16 +26044,12 @@ cdef class VgpuSchedulerState_v1: raise ValueError("ptr must not be null (0)") cdef VgpuSchedulerState_v1 obj = VgpuSchedulerState_v1.__new__(VgpuSchedulerState_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlVgpuSchedulerState_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating VgpuSchedulerState_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlVgpuSchedulerState_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlVgpuSchedulerState_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -26584,26 +26076,16 @@ cdef class GridLicensableFeatures: .. seealso:: `nvmlGridLicensableFeatures_t` """ cdef: + nvmlGridLicensableFeatures_t _data nvmlGridLicensableFeatures_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlGridLicensableFeatures_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating GridLicensableFeatures") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlGridLicensableFeatures_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.GridLicensableFeatures object at {hex(id(self))}>" @@ -26632,14 +26114,20 @@ cdef class GridLicensableFeatures: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlGridLicensableFeatures_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating GridLicensableFeatures") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlGridLicensableFeatures_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlGridLicensableFeatures_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlGridLicensableFeatures_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlGridLicensableFeatures_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -26703,16 +26191,12 @@ cdef class GridLicensableFeatures: raise ValueError("ptr must not be null (0)") cdef GridLicensableFeatures obj = GridLicensableFeatures.__new__(GridLicensableFeatures) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlGridLicensableFeatures_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating GridLicensableFeatures") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlGridLicensableFeatures_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlGridLicensableFeatures_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -26739,26 +26223,16 @@ cdef class NvLinkInfo_v2: .. seealso:: `nvmlNvLinkInfo_v2_t` """ cdef: + nvmlNvLinkInfo_v2_t _data nvmlNvLinkInfo_v2_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlNvLinkInfo_v2_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating NvLinkInfo_v2") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlNvLinkInfo_v2_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.NvLinkInfo_v2 object at {hex(id(self))}>" @@ -26787,14 +26261,20 @@ cdef class NvLinkInfo_v2: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlNvLinkInfo_v2_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating NvLinkInfo_v2") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlNvLinkInfo_v2_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlNvLinkInfo_v2_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlNvLinkInfo_v2_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlNvLinkInfo_v2_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -26863,16 +26343,12 @@ cdef class NvLinkInfo_v2: raise ValueError("ptr must not be null (0)") cdef NvLinkInfo_v2 obj = NvLinkInfo_v2.__new__(NvLinkInfo_v2) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlNvLinkInfo_v2_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating NvLinkInfo_v2") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlNvLinkInfo_v2_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlNvLinkInfo_v2_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -27727,24 +27203,24 @@ cdef class _py_anon_pod8: """ cdef: cuda_bindings_nvml__anon_pod8 *_ptr - object _owner - bint _owned + _cyb_PyObject *_owner bint _readonly def __init__(self): self._ptr = _cyb_calloc(1, sizeof(cuda_bindings_nvml__anon_pod8)) if self._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod8") - self._owner = None - self._owned = True + self._owner = NULL self._readonly = False def __dealloc__(self): cdef cuda_bindings_nvml__anon_pod8 *ptr - if self._owned and self._ptr != NULL: + if self._owner == NULL and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) + _cyb_Py_CLEAR(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}._py_anon_pod8 object at {hex(id(self))}>" @@ -27774,14 +27250,24 @@ cdef class _py_anon_pod8: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(cuda_bindings_nvml__anon_pod8)) - if self._ptr == NULL: - raise MemoryError("Error allocating _py_anon_pod8") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(cuda_bindings_nvml__anon_pod8)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(cuda_bindings_nvml__anon_pod8): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(cuda_bindings_nvml__anon_pod8), view.len) + ) + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_CLEAR(self._owner) + self._ptr = _cyb_malloc(sizeof(cuda_bindings_nvml__anon_pod8)) + if self._ptr == NULL: + raise MemoryError("Error allocating _py_anon_pod8") + _cyb_memcpy(self._ptr, view.buf, sizeof(cuda_bindings_nvml__anon_pod8)) + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -27850,12 +27336,11 @@ cdef class _py_anon_pod8: if obj._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod8") _cyb_memcpy((obj._ptr), ptr, sizeof(cuda_bindings_nvml__anon_pod8)) - obj._owner = None - obj._owned = True + obj._owner = NULL else: obj._ptr = ptr - obj._owner = owner - obj._owned = False + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -28195,26 +27680,16 @@ cdef class PerfMetricsSamples_v1: .. seealso:: `nvmlPerfMetricsSamples_v1_t` """ cdef: + nvmlPerfMetricsSamples_v1_t _data nvmlPerfMetricsSamples_v1_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): - self._ptr = _cyb_calloc(1, sizeof(nvmlPerfMetricsSamples_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating PerfMetricsSamples_v1") + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = False - def __dealloc__(self): - cdef nvmlPerfMetricsSamples_v1_t *ptr - if self._owned and self._ptr != NULL: - ptr = self._ptr - self._ptr = NULL - _cyb_free(ptr) - def __repr__(self): return f"<{__name__}.PerfMetricsSamples_v1 object at {hex(id(self))}>" @@ -28243,14 +27718,20 @@ cdef class PerfMetricsSamples_v1: pass def __setitem__(self, key, val): - if key == 0 and isinstance(val, _numpy.ndarray): - self._ptr = _cyb_malloc(sizeof(nvmlPerfMetricsSamples_v1_t)) - if self._ptr == NULL: - raise MemoryError("Error allocating PerfMetricsSamples_v1") - _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlPerfMetricsSamples_v1_t)) - self._owner = None - self._owned = True - self._readonly = not val.flags.writeable + cdef _cyb_Py_buffer view + if key == 0: + _cyb_PyObject_GetBuffer(val, &view, _cyb_PyBUF_SIMPLE) + try: + if view.len < sizeof(nvmlPerfMetricsSamples_v1_t): + raise ValueError( + "source buffer too small: expected at least %d bytes, got %d" % (sizeof(nvmlPerfMetricsSamples_v1_t), view.len) + ) + _cyb_memcpy(&self._data, view.buf, sizeof(nvmlPerfMetricsSamples_v1_t)) + self._ptr = &self._data + self._owner = None + self._readonly = view.readonly != 0 + finally: + _cyb_PyBuffer_Release(&view) else: setattr(self, key, val) @@ -28303,16 +27784,12 @@ cdef class PerfMetricsSamples_v1: raise ValueError("ptr must not be null (0)") cdef PerfMetricsSamples_v1 obj = PerfMetricsSamples_v1.__new__(PerfMetricsSamples_v1) if owner is None: - obj._ptr = _cyb_malloc(sizeof(nvmlPerfMetricsSamples_v1_t)) - if obj._ptr == NULL: - raise MemoryError("Error allocating PerfMetricsSamples_v1") - _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlPerfMetricsSamples_v1_t)) + _cyb_memcpy(&obj._data, ptr, sizeof(nvmlPerfMetricsSamples_v1_t)) + obj._ptr = &obj._data obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj diff --git a/cuda_bindings/docs/source/release/13.5.0-notes.rst b/cuda_bindings/docs/source/release/13.5.0-notes.rst index c64e702b45b..6993d8ad76d 100644 --- a/cuda_bindings/docs/source/release/13.5.0-notes.rst +++ b/cuda_bindings/docs/source/release/13.5.0-notes.rst @@ -13,6 +13,7 @@ Enhancements - ``cuda-bindings`` docstrings now include the full documentation from the upstream CTK, not just the first paragraph. - For all ``cuda-bindings`` APIs, functions that accept a ``bytes`` object will also accept ``None``, which is treated as ``NULL``. - For all ``cuda-bindings`` APIs, functions that accept a struct wrapper will accept the struct wrapper directly, rather than requiring getting the ``.ptr`` property. +- Creating wrapped structs (AUTO_LOWPP_CLASS) in ``cuda-bindings`` should now be faster in most cases, because it requires 1 heap allocation rather than 2. Bugfixes --------