diff --git a/cuda_bindings/cuda/bindings/cudla.pyx b/cuda_bindings/cuda/bindings/cudla.pyx index 175a6ba0d2..ad34a5ea0e 100644 --- a/cuda_bindings/cuda/bindings/cudla.pyx +++ b/cuda_bindings/cuda/bindings/cudla.pyx @@ -2,7 +2,7 @@ # SPDX-License-Identifier: Apache-2.0 # This code was automatically generated across versions from 1.5.0 to 13.3.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=3ee237ed16e651bae93e2bc6d4d63dcf99b309ad7a74cb3e2bd5b9e540e714f4 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=070eb43e310d26121650152783aebdc78bf465a29554fe5b911301c9d9ba2c28 # <<<< PREAMBLE CONTENT >>>> @@ -10,11 +10,6 @@ cimport cpython as _cyb_cpython cimport cpython.buffer as _cyb_cpython_buffer from cython cimport view as _cyb_view -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, @@ -99,26 +94,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))}>" @@ -148,12 +133,9 @@ cdef class ExternalMemoryHandleDesc: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(cudlaExternalMemoryHandleDesc_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -207,16 +189,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 @@ -241,26 +219,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))}>" @@ -290,12 +258,9 @@ cdef class ExternalSemaphoreHandleDesc: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(cudlaExternalSemaphoreHandleDesc_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -338,16 +303,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 @@ -383,26 +344,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))}>" @@ -432,12 +383,9 @@ cdef class ModuleTensorDescriptor: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(cudlaModuleTensorDescriptor)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -611,16 +559,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 @@ -646,26 +590,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))}>" @@ -695,12 +629,9 @@ cdef class Fence: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(CudlaFence)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -754,16 +685,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 @@ -783,26 +710,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))}>" @@ -832,12 +749,9 @@ cdef class DevAttribute: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(cudlaDevAttribute)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -891,16 +805,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 @@ -922,26 +832,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))}>" @@ -971,12 +871,9 @@ cdef class ModuleAttribute: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(cudlaModuleAttribute)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -1052,16 +949,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 @@ -1087,28 +980,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))}>" @@ -1138,12 +1021,9 @@ cdef class WaitEvents: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(cudlaWaitEvents)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -1191,16 +1071,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 @@ -1228,28 +1104,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))}>" @@ -1279,12 +1145,9 @@ cdef class SignalEvents: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(cudlaSignalEvents)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -1357,16 +1220,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 @@ -1398,28 +1257,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))}>" @@ -1449,12 +1298,9 @@ cdef class Task: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(cudlaTask)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -1569,16 +1415,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 fbc9c20dc4..1864f6aa09 100644 --- a/cuda_bindings/cuda/bindings/cufile.pyx +++ b/cuda_bindings/cuda/bindings/cufile.pyx @@ -3,7 +3,7 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.1 to 13.3.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=4567ca64d02631fc8d6ed11af8164d72c86b4686c105fd733d186e6c92512749 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=93bda6a9ebbc6155b50ef5165996f97e813dbc12de6f956e80fc613534c406c3 # <<<< PREAMBLE CONTENT >>>> @@ -11,6 +11,11 @@ cimport cpython as _cyb_cpython cimport cpython.buffer as _cyb_cpython_buffer cimport cpython.memoryview as _cyb_cpython_memoryview +from cpython.object cimport PyObject as _cyb_PyObject +from cpython.ref cimport ( + Py_XDECREF as _cyb_Py_XDECREF, + Py_XINCREF as _cyb_Py_XINCREF, +) from cython cimport view as _cyb_view from libc.stdlib cimport ( calloc as _cyb_calloc, @@ -96,24 +101,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_XDECREF(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}._py_anon_pod1 object at {hex(id(self))}>" @@ -144,12 +149,14 @@ cdef class _py_anon_pod1: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_XDECREF(self._owner) 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -207,12 +214,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 @@ -241,24 +247,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_XDECREF(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}._py_anon_pod3 object at {hex(id(self))}>" @@ -289,12 +295,14 @@ cdef class _py_anon_pod3: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_XDECREF(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, val.ctypes.data, sizeof((NULL).u.batch)) - self._owner = None - self._owned = True + self._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -374,12 +382,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 @@ -571,24 +578,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_XDECREF(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}.OpCounter object at {hex(id(self))}>" @@ -619,12 +626,14 @@ cdef class OpCounter: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_XDECREF(self._owner) 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -682,12 +691,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 @@ -1357,24 +1365,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_XDECREF(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}._py_anon_pod2 object at {hex(id(self))}>" @@ -1405,12 +1413,14 @@ cdef class _py_anon_pod2: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_XDECREF(self._owner) 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -1458,12 +1468,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 @@ -1531,24 +1540,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_XDECREF(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}.StatsLevel1 object at {hex(id(self))}>" @@ -1579,12 +1588,14 @@ cdef class StatsLevel1: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_XDECREF(self._owner) 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -2114,12 +2125,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 @@ -2334,24 +2344,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_XDECREF(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}.StatsLevel2 object at {hex(id(self))}>" @@ -2382,12 +2392,14 @@ cdef class StatsLevel2: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_XDECREF(self._owner) 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -2469,12 +2481,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 @@ -2501,26 +2512,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))}>" @@ -2550,12 +2551,9 @@ cdef class StatsLevel3: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(CUfileStatsLevel3_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -2624,16 +2622,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 a51d426436..d42069cb50 100644 --- a/cuda_bindings/cuda/bindings/nvml.pyx +++ b/cuda_bindings/cuda/bindings/nvml.pyx @@ -3,7 +3,7 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.1 to 13.3.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=e47a16bd9956de14a991ded5d1aef667cdd26a141e27db5b2015b91be6918d3c +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=36fa912d142c37c3dd2f4289b3171ff7f090cd9d2de90a8adc87dac5ef3d4e4d # <<<< PREAMBLE CONTENT >>>> @@ -11,6 +11,11 @@ cimport cpython as _cyb_cpython cimport cpython.buffer as _cyb_cpython_buffer cimport cpython.memoryview as _cyb_cpython_memoryview +from cpython.object cimport PyObject as _cyb_PyObject +from cpython.ref cimport ( + Py_XDECREF as _cyb_Py_XDECREF, + Py_XINCREF as _cyb_Py_XINCREF, +) from cython cimport view as _cyb_view from libc.stdlib cimport ( calloc as _cyb_calloc, @@ -2189,26 +2194,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))}>" @@ -2238,12 +2233,9 @@ cdef class PciInfoExt_v1: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlPciInfoExt_v1_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -2378,16 +2370,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 @@ -2419,24 +2407,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_XDECREF(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}.PciInfo object at {hex(id(self))}>" @@ -2467,12 +2455,14 @@ cdef class PciInfo: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_XDECREF(self._owner) 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -2593,12 +2583,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 @@ -2624,26 +2613,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))}>" @@ -2673,12 +2652,9 @@ cdef class Utilization: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlUtilization_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -2732,16 +2708,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 @@ -2768,26 +2740,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))}>" @@ -2817,12 +2779,9 @@ cdef class Memory: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlMemory_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -2887,16 +2846,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 @@ -2925,26 +2880,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))}>" @@ -2974,12 +2919,9 @@ cdef class Memory_v2: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlMemory_v2_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -3066,16 +3008,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 @@ -3102,26 +3040,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))}>" @@ -3151,12 +3079,9 @@ cdef class BAR1Memory: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlBAR1Memory_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -3221,16 +3146,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 @@ -3629,26 +3550,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))}>" @@ -3678,12 +3589,9 @@ cdef class DeviceAttributes: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlDeviceAttributes_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -3814,16 +3722,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 @@ -3848,26 +3752,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))}>" @@ -3897,12 +3791,9 @@ cdef class C2cModeInfo_v1: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlC2cModeInfo_v1_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -3945,16 +3836,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 @@ -3983,26 +3870,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))}>" @@ -4032,12 +3909,9 @@ cdef class RowRemapperHistogramValues: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlRowRemapperHistogramValues_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -4124,16 +3998,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 @@ -4312,24 +4182,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_XDECREF(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}.Value object at {hex(id(self))}>" @@ -4360,12 +4230,14 @@ cdef class Value: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_XDECREF(self._owner) 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -4478,12 +4350,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 @@ -4513,24 +4384,24 @@ cdef class _py_anon_pod0: """ cdef: cuda_bindings_nvml__anon_pod0 *_ptr - object _owner - bint _owned + _cyb_PyObject *_owner bint _readonly def __init__(self): self._ptr = _cyb_calloc(1, sizeof(cuda_bindings_nvml__anon_pod0)) if self._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod0") - self._owner = None - self._owned = True + self._owner = NULL self._readonly = False def __dealloc__(self): cdef cuda_bindings_nvml__anon_pod0 *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_XDECREF(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}._py_anon_pod0 object at {hex(id(self))}>" @@ -4561,12 +4432,14 @@ cdef class _py_anon_pod0: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_XDECREF(self._owner) self._ptr = _cyb_malloc(sizeof(cuda_bindings_nvml__anon_pod0)) if self._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod0") _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(cuda_bindings_nvml__anon_pod0)) - self._owner = None - self._owned = True + self._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -4657,12 +4530,11 @@ cdef class _py_anon_pod0: if obj._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod0") _cyb_memcpy((obj._ptr), ptr, sizeof(cuda_bindings_nvml__anon_pod0)) - 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 @@ -4690,26 +4562,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))}>" @@ -4739,12 +4601,9 @@ cdef class CoolerInfo_v1: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlCoolerInfo_v1_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -4820,16 +4679,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 @@ -5012,26 +4867,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))}>" @@ -5061,12 +4906,9 @@ cdef class ClockOffset_v1: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlClockOffset_v1_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -5164,16 +5006,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 @@ -5636,26 +5474,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))}>" @@ -5685,12 +5513,9 @@ cdef class EccSramErrorStatus_v1: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlEccSramErrorStatus_v1_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -5865,16 +5690,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 @@ -5906,26 +5727,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))}>" @@ -5955,12 +5766,9 @@ cdef class PlatformInfo_v1: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlPlatformInfo_v1_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -6092,16 +5900,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 @@ -6133,26 +5937,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))}>" @@ -6182,12 +5976,9 @@ cdef class PlatformInfo_v2: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlPlatformInfo_v2_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -6319,16 +6110,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 @@ -6357,24 +6144,24 @@ cdef class _py_anon_pod1: """ cdef: cuda_bindings_nvml__anon_pod1 *_ptr - object _owner - bint _owned + _cyb_PyObject *_owner bint _readonly def __init__(self): self._ptr = _cyb_calloc(1, sizeof(cuda_bindings_nvml__anon_pod1)) 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_nvml__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_XDECREF(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}._py_anon_pod1 object at {hex(id(self))}>" @@ -6405,12 +6192,14 @@ cdef class _py_anon_pod1: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_XDECREF(self._owner) self._ptr = _cyb_malloc(sizeof(cuda_bindings_nvml__anon_pod1)) if self._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod1") _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(cuda_bindings_nvml__anon_pod1)) - self._owner = None - self._owned = True + self._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -6490,12 +6279,11 @@ cdef class _py_anon_pod1: if obj._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod1") _cyb_memcpy((obj._ptr), ptr, sizeof(cuda_bindings_nvml__anon_pod1)) - 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 @@ -6524,28 +6312,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))}>" @@ -6575,12 +6353,9 @@ cdef class VgpuPlacementList_v2: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlVgpuPlacementList_v2_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -6664,16 +6439,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 @@ -6700,26 +6471,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))}>" @@ -6749,12 +6510,9 @@ cdef class VgpuTypeBar1Info_v1: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlVgpuTypeBar1Info_v1_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -6808,16 +6566,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 @@ -7091,24 +6845,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_XDECREF(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}._py_anon_pod2 object at {hex(id(self))}>" @@ -7139,12 +6893,14 @@ cdef class _py_anon_pod2: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_XDECREF(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, val.ctypes.data, sizeof(cuda_bindings_nvml__anon_pod2)) - self._owner = None - self._owned = True + self._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -7202,12 +6958,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 @@ -7233,24 +6988,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_XDECREF(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}._py_anon_pod3 object at {hex(id(self))}>" @@ -7281,12 +7036,14 @@ cdef class _py_anon_pod3: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_XDECREF(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, val.ctypes.data, sizeof(cuda_bindings_nvml__anon_pod3)) - self._owner = None - self._owned = True + self._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -7333,12 +7090,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 @@ -7566,24 +7322,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_XDECREF(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}._py_anon_pod4 object at {hex(id(self))}>" @@ -7614,12 +7370,14 @@ cdef class _py_anon_pod4: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_XDECREF(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, val.ctypes.data, sizeof(cuda_bindings_nvml__anon_pod4)) - self._owner = None - self._owned = True + self._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -7677,12 +7435,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 @@ -7708,24 +7465,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_XDECREF(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}._py_anon_pod5 object at {hex(id(self))}>" @@ -7756,12 +7513,14 @@ cdef class _py_anon_pod5: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_XDECREF(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, val.ctypes.data, sizeof(cuda_bindings_nvml__anon_pod5)) - self._owner = None - self._owned = True + self._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -7808,12 +7567,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 @@ -7845,26 +7603,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))}>" @@ -7894,12 +7642,9 @@ cdef class VgpuSchedulerCapabilities: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlVgpuSchedulerCapabilities_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -8025,16 +7770,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 @@ -8066,24 +7807,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_XDECREF(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}.VgpuLicenseExpiry object at {hex(id(self))}>" @@ -8114,12 +7855,14 @@ cdef class VgpuLicenseExpiry: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_XDECREF(self._owner) 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -8232,12 +7975,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 @@ -8269,24 +8011,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_XDECREF(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}.GridLicenseExpiry object at {hex(id(self))}>" @@ -8317,12 +8059,14 @@ cdef class GridLicenseExpiry: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_XDECREF(self._owner) 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -8435,12 +8179,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 @@ -8467,28 +8210,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))}>" @@ -8518,12 +8251,9 @@ cdef class VgpuTypeIdInfo_v1: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlVgpuTypeIdInfo_v1_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -8585,16 +8315,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 @@ -8622,28 +8348,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))}>" @@ -8673,12 +8389,9 @@ cdef class ActiveVgpuInstanceInfo_v1: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlActiveVgpuInstanceInfo_v1_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -8740,16 +8453,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 @@ -8779,28 +8488,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))}>" @@ -8830,12 +8529,9 @@ cdef class VgpuCreatablePlacementInfo_v1: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlVgpuCreatablePlacementInfo_v1_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -8919,16 +8615,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 @@ -9106,26 +8798,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))}>" @@ -9155,12 +8837,9 @@ cdef class LedState: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlLedState_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -9218,16 +8897,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 @@ -9255,26 +8930,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))}>" @@ -9304,12 +8969,9 @@ cdef class UnitInfo: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlUnitInfo_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -9401,16 +9063,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 @@ -9438,26 +9096,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))}>" @@ -9487,12 +9135,9 @@ cdef class PSUInfo: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlPSUInfo_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -9572,16 +9217,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 @@ -9763,26 +9404,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))}>" @@ -9812,12 +9443,9 @@ cdef class EventData: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlEventData_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -9904,16 +9532,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 @@ -10097,26 +9721,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))}>" @@ -10146,12 +9760,9 @@ cdef class AccountingStats: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlAccountingStats_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -10249,16 +9860,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 @@ -10510,26 +10117,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))}>" @@ -10559,12 +10156,9 @@ cdef class FBCStats: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlFBCStats_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -10629,16 +10223,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 @@ -10937,26 +10527,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))}>" @@ -10986,12 +10566,9 @@ cdef class ConfComputeSystemCaps: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlConfComputeSystemCaps_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -11045,16 +10622,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 @@ -11081,26 +10654,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))}>" @@ -11130,12 +10693,9 @@ cdef class ConfComputeSystemState: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlConfComputeSystemState_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -11200,16 +10760,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 @@ -11238,26 +10794,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))}>" @@ -11287,12 +10833,9 @@ cdef class SystemConfComputeSettings_v1: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlSystemConfComputeSettings_v1_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -11379,16 +10922,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 @@ -11414,26 +10953,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))}>" @@ -11463,12 +10992,9 @@ cdef class ConfComputeMemSizeInfo: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlConfComputeMemSizeInfo_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -11522,16 +11048,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 @@ -11559,26 +11081,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))}>" @@ -11608,12 +11120,9 @@ cdef class ConfComputeGpuCertificate: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlConfComputeGpuCertificate_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -11689,16 +11198,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 @@ -11728,26 +11233,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))}>" @@ -11777,12 +11272,9 @@ cdef class ConfComputeGpuAttestationReport: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlConfComputeGpuAttestationReport_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -11886,16 +11378,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 @@ -11925,26 +11413,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))}>" @@ -11974,12 +11452,9 @@ cdef class GpuFabricInfo_v2: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlGpuFabricInfo_v2_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -12083,16 +11558,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 @@ -12119,26 +11590,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))}>" @@ -12168,12 +11629,9 @@ cdef class NvlinkSupportedBwModes_v1: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlNvlinkSupportedBwModes_v1_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -12238,16 +11696,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 @@ -12274,26 +11728,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))}>" @@ -12323,12 +11767,9 @@ cdef class NvlinkGetBwMode_v1: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlNvlinkGetBwMode_v1_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -12393,16 +11834,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 @@ -12429,26 +11866,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))}>" @@ -12478,12 +11905,9 @@ cdef class NvlinkSetBwMode_v1: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlNvlinkSetBwMode_v1_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -12548,16 +11972,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 @@ -12584,24 +12004,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_XDECREF(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}.VgpuVersion object at {hex(id(self))}>" @@ -12632,12 +12052,14 @@ cdef class VgpuVersion: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_XDECREF(self._owner) 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -12695,12 +12117,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 @@ -12734,26 +12155,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))}>" @@ -12783,12 +12194,9 @@ cdef class VgpuMetadata: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlVgpuMetadata_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -12931,16 +12339,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 @@ -12966,26 +12370,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))}>" @@ -13015,12 +12409,9 @@ cdef class VgpuPgpuCompatibility: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlVgpuPgpuCompatibility_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -13074,16 +12465,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 @@ -13273,26 +12660,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))}>" @@ -13322,12 +12699,9 @@ cdef class GpuInstanceProfileInfo_v3: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlGpuInstanceProfileInfo_v3_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -13506,16 +12880,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 @@ -13703,26 +13073,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))}>" @@ -13752,12 +13112,9 @@ cdef class ComputeInstanceProfileInfo_v2: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlComputeInstanceProfileInfo_v2_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -13914,16 +13271,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 @@ -13959,26 +13312,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))}>" @@ -14008,12 +13351,9 @@ cdef class ComputeInstanceProfileInfo_v3: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlComputeInstanceProfileInfo_v3_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -14181,16 +13521,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 @@ -14216,26 +13552,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))}>" @@ -14265,12 +13591,9 @@ cdef class DeviceAddressingMode_v1: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlDeviceAddressingMode_v1_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -14324,16 +13647,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 @@ -14360,26 +13679,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))}>" @@ -14409,12 +13718,9 @@ cdef class RepairStatus_v1: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlRepairStatus_v1_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -14479,16 +13785,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 @@ -14515,26 +13817,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))}>" @@ -14564,12 +13856,9 @@ cdef class DevicePowerMizerModes_v1: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlDevicePowerMizerModes_v1_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -14634,16 +13923,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 @@ -14887,26 +14172,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))}>" @@ -14936,12 +14211,9 @@ cdef class GpuFabricInfo_v3: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlGpuFabricInfo_v3_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -15056,16 +14328,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 @@ -15091,26 +14359,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))}>" @@ -15140,12 +14398,9 @@ cdef class NvLinkInfo_v1: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlNvLinkInfo_v1_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -15199,16 +14454,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 @@ -15237,24 +14488,24 @@ cdef class NvlinkFirmwareVersion: """ cdef: nvmlNvlinkFirmwareVersion_t *_ptr - object _owner - bint _owned + _cyb_PyObject *_owner bint _readonly def __init__(self): self._ptr = _cyb_calloc(1, sizeof(nvmlNvlinkFirmwareVersion_t)) if self._ptr == NULL: raise MemoryError("Error allocating NvlinkFirmwareVersion") - self._owner = None - self._owned = True + self._owner = NULL self._readonly = False def __dealloc__(self): cdef nvmlNvlinkFirmwareVersion_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_XDECREF(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}.NvlinkFirmwareVersion object at {hex(id(self))}>" @@ -15285,12 +14536,14 @@ cdef class NvlinkFirmwareVersion: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_XDECREF(self._owner) self._ptr = _cyb_malloc(sizeof(nvmlNvlinkFirmwareVersion_t)) if self._ptr == NULL: raise MemoryError("Error allocating NvlinkFirmwareVersion") _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlNvlinkFirmwareVersion_t)) - self._owner = None - self._owned = True + self._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -15370,12 +14623,11 @@ cdef class NvlinkFirmwareVersion: if obj._ptr == NULL: raise MemoryError("Error allocating NvlinkFirmwareVersion") _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlNvlinkFirmwareVersion_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 @@ -15401,24 +14653,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_XDECREF(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}.PRMCounterInput_v1 object at {hex(id(self))}>" @@ -15449,12 +14701,14 @@ cdef class PRMCounterInput_v1: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_XDECREF(self._owner) 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -15501,12 +14755,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 @@ -15534,26 +14787,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))}>" @@ -15583,12 +14826,9 @@ cdef class VgpuSchedulerStateInfo_v2: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlVgpuSchedulerStateInfo_v2_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -15664,16 +14904,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 @@ -15914,26 +15150,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))}>" @@ -15963,12 +15189,9 @@ cdef class VgpuSchedulerState_v2: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlVgpuSchedulerState_v2_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -16044,16 +15267,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 @@ -16079,26 +15298,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))}>" @@ -16128,12 +15337,9 @@ cdef class ExcludedDeviceInfo: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlExcludedDeviceInfo_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -16192,16 +15398,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 @@ -16229,28 +15431,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))}>" @@ -16280,12 +15472,9 @@ cdef class ProcessDetailList_v1: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlProcessDetailList_v1_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -16355,16 +15544,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 @@ -16391,26 +15576,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))}>" @@ -16440,12 +15615,9 @@ cdef class BridgeChipHierarchy: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlBridgeChipHierarchy_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -16494,16 +15666,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 @@ -17299,24 +16467,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_XDECREF(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}.PRMCounterValue_v1 object at {hex(id(self))}>" @@ -17347,12 +16515,14 @@ cdef class PRMCounterValue_v1: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_XDECREF(self._owner) 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -17422,12 +16592,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 @@ -17453,26 +16622,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))}>" @@ -17502,12 +16661,9 @@ cdef class GpuThermalSettings: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlGpuThermalSettings_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -17564,16 +16720,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 @@ -17600,26 +16752,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))}>" @@ -17649,12 +16791,9 @@ cdef class ClkMonStatus: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlClkMonStatus_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -17714,16 +16853,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 @@ -17751,28 +16886,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))}>" @@ -17802,12 +16927,9 @@ cdef class ProcessesUtilizationInfo_v1: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlProcessesUtilizationInfo_v1_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -17877,16 +16999,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 @@ -17913,26 +17031,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))}>" @@ -17962,12 +17070,9 @@ cdef class GpuDynamicPstatesInfo: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlGpuDynamicPstatesInfo_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -18024,16 +17129,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 @@ -18061,28 +17162,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))}>" @@ -18112,12 +17203,9 @@ cdef class VgpuProcessesUtilizationInfo_v1: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlVgpuProcessesUtilizationInfo_v1_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -18187,16 +17275,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 @@ -18218,24 +17302,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_XDECREF(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}.VgpuSchedulerParams object at {hex(id(self))}>" @@ -18266,12 +17350,14 @@ cdef class VgpuSchedulerParams: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_XDECREF(self._owner) 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -18331,12 +17417,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 @@ -18357,24 +17442,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_XDECREF(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}.VgpuSchedulerSetParams object at {hex(id(self))}>" @@ -18405,12 +17490,14 @@ cdef class VgpuSchedulerSetParams: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_XDECREF(self._owner) 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -18470,12 +17557,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 @@ -18502,26 +17588,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))}>" @@ -18551,12 +17627,9 @@ cdef class VgpuLicenseInfo: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlVgpuLicenseInfo_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -18622,16 +17695,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 @@ -18852,26 +17921,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))}>" @@ -18901,12 +17960,9 @@ cdef class UnitFanSpeeds: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlUnitFanSpeeds_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -18963,16 +18019,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 @@ -19004,26 +18056,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))}>" @@ -19053,12 +18095,9 @@ cdef class VgpuPgpuMetadata: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlVgpuPgpuMetadata_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -19176,16 +18215,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 @@ -19213,26 +18248,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))}>" @@ -19262,12 +18287,9 @@ cdef class GpuInstanceInfo: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlGpuInstanceInfo_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -19344,16 +18366,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 @@ -19382,26 +18400,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))}>" @@ -19431,12 +18439,9 @@ cdef class ComputeInstanceInfo: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlComputeInstanceInfo_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -19524,16 +18529,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 @@ -19560,28 +18561,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))}>" @@ -19611,12 +18602,9 @@ cdef class EccSramUniqueUncorrectedErrorCounts_v1: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlEccSramUniqueUncorrectedErrorCounts_v1_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -19675,16 +18663,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 @@ -19712,24 +18696,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_XDECREF(self._owner) + self._owner = NULL def __repr__(self): return f"<{__name__}.NvlinkFirmwareInfo object at {hex(id(self))}>" @@ -19760,12 +18744,14 @@ cdef class NvlinkFirmwareInfo: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner == NULL and self._ptr != NULL: + _cyb_free(self._ptr) + _cyb_Py_XDECREF(self._owner) 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -19826,12 +18812,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 @@ -19861,26 +18846,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))}>" @@ -19910,12 +18885,9 @@ cdef class VgpuSchedulerLogInfo_v2: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlVgpuSchedulerLogInfo_v2_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -20016,16 +18988,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 @@ -20054,28 +19022,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))}>" @@ -20105,12 +19063,9 @@ cdef class VgpuInstancesUtilizationInfo_v1: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlVgpuInstancesUtilizationInfo_v1_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -20191,16 +19146,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 @@ -20392,26 +19343,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))}>" @@ -20441,12 +19382,9 @@ cdef class VgpuSchedulerLog: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlVgpuSchedulerLog_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -20548,16 +19486,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 @@ -20584,26 +19518,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))}>" @@ -20633,12 +19557,9 @@ cdef class VgpuSchedulerGetState: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlVgpuSchedulerGetState_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -20704,16 +19625,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 @@ -20742,26 +19659,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))}>" @@ -20791,12 +19698,9 @@ cdef class VgpuSchedulerStateInfo_v1: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlVgpuSchedulerStateInfo_v1_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -20884,16 +19788,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 @@ -20924,26 +19824,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))}>" @@ -20973,12 +19863,9 @@ cdef class VgpuSchedulerLogInfo_v1: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlVgpuSchedulerLogInfo_v1_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -21091,16 +19978,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 @@ -21129,26 +20012,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))}>" @@ -21178,12 +20051,9 @@ cdef class VgpuSchedulerState_v1: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlVgpuSchedulerState_v1_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -21271,16 +20141,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 @@ -21307,26 +20173,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))}>" @@ -21356,12 +20212,9 @@ cdef class GridLicensableFeatures: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlGridLicensableFeatures_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -21421,16 +20274,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 @@ -21457,26 +20306,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))}>" @@ -21506,12 +20345,9 @@ cdef class NvLinkInfo_v2: 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)) + _cyb_memcpy(&self._data, val.ctypes.data, sizeof(nvmlNvLinkInfo_v2_t)) + self._ptr = &self._data self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -21577,16 +20413,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