From ad2d4c5fc88e923c3c47b48bb6841d6d393f24bc Mon Sep 17 00:00:00 2001 From: Michael Droettboom Date: Thu, 16 Jul 2026 15:50:06 -0400 Subject: [PATCH 1/2] Use internal/external storage for some auto-generated classes --- cuda_bindings/cuda/bindings/cudla.pyx | 268 +-- cuda_bindings/cuda/bindings/cufile.pyx | 85 +- cuda_bindings/cuda/bindings/nvml.pyx | 2185 +++++------------------- 3 files changed, 552 insertions(+), 1986 deletions(-) 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..cbe11968d8 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=6a92dc0345783c19c92a86ab536639223cf0274bbb87877f7e4ac43b2e949053 # <<<< PREAMBLE CONTENT >>>> @@ -97,7 +97,6 @@ cdef class _py_anon_pod1: cdef: cuda_bindings_cufile__anon_pod1 *_ptr object _owner - bint _owned bint _readonly def __init__(self): @@ -105,12 +104,11 @@ cdef class _py_anon_pod1: if self._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod1") self._owner = None - self._owned = True self._readonly = False def __dealloc__(self): cdef cuda_bindings_cufile__anon_pod1 *ptr - if self._owned and self._ptr != NULL: + if self._owner is None and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) @@ -144,12 +142,13 @@ cdef class _py_anon_pod1: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner is None and self._ptr != NULL: + _cyb_free(self._ptr) self._ptr = _cyb_malloc(sizeof((NULL).handle)) if self._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod1") _cyb_memcpy(self._ptr, val.ctypes.data, sizeof((NULL).handle)) self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -208,11 +207,9 @@ cdef class _py_anon_pod1: raise MemoryError("Error allocating _py_anon_pod1") _cyb_memcpy((obj._ptr), ptr, sizeof((NULL).handle)) obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -242,7 +239,6 @@ cdef class _py_anon_pod3: cdef: cuda_bindings_cufile__anon_pod3 *_ptr object _owner - bint _owned bint _readonly def __init__(self): @@ -250,12 +246,11 @@ cdef class _py_anon_pod3: if self._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod3") self._owner = None - self._owned = True self._readonly = False def __dealloc__(self): cdef cuda_bindings_cufile__anon_pod3 *ptr - if self._owned and self._ptr != NULL: + if self._owner is None and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) @@ -289,12 +284,13 @@ cdef class _py_anon_pod3: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner is None and self._ptr != NULL: + _cyb_free(self._ptr) self._ptr = _cyb_malloc(sizeof((NULL).u.batch)) if self._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod3") _cyb_memcpy(self._ptr, val.ctypes.data, sizeof((NULL).u.batch)) self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -375,11 +371,9 @@ cdef class _py_anon_pod3: raise MemoryError("Error allocating _py_anon_pod3") _cyb_memcpy((obj._ptr), ptr, sizeof((NULL).u.batch)) obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -572,7 +566,6 @@ cdef class OpCounter: cdef: CUfileOpCounter_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): @@ -580,12 +573,11 @@ cdef class OpCounter: if self._ptr == NULL: raise MemoryError("Error allocating OpCounter") self._owner = None - self._owned = True self._readonly = False def __dealloc__(self): cdef CUfileOpCounter_t *ptr - if self._owned and self._ptr != NULL: + if self._owner is None and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) @@ -619,12 +611,13 @@ cdef class OpCounter: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner is None and self._ptr != NULL: + _cyb_free(self._ptr) self._ptr = _cyb_malloc(sizeof(CUfileOpCounter_t)) if self._ptr == NULL: raise MemoryError("Error allocating OpCounter") _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(CUfileOpCounter_t)) self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -683,11 +676,9 @@ cdef class OpCounter: raise MemoryError("Error allocating OpCounter") _cyb_memcpy((obj._ptr), ptr, sizeof(CUfileOpCounter_t)) obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -1358,7 +1349,6 @@ cdef class _py_anon_pod2: cdef: cuda_bindings_cufile__anon_pod2 *_ptr object _owner - bint _owned bint _readonly def __init__(self): @@ -1366,12 +1356,11 @@ cdef class _py_anon_pod2: if self._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod2") self._owner = None - self._owned = True self._readonly = False def __dealloc__(self): cdef cuda_bindings_cufile__anon_pod2 *ptr - if self._owned and self._ptr != NULL: + if self._owner is None and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) @@ -1405,12 +1394,13 @@ cdef class _py_anon_pod2: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner is None and self._ptr != NULL: + _cyb_free(self._ptr) self._ptr = _cyb_malloc(sizeof((NULL).u)) if self._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod2") _cyb_memcpy(self._ptr, val.ctypes.data, sizeof((NULL).u)) self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -1459,11 +1449,9 @@ cdef class _py_anon_pod2: raise MemoryError("Error allocating _py_anon_pod2") _cyb_memcpy((obj._ptr), ptr, sizeof((NULL).u)) obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -1532,7 +1520,6 @@ cdef class StatsLevel1: cdef: CUfileStatsLevel1_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): @@ -1540,12 +1527,11 @@ cdef class StatsLevel1: if self._ptr == NULL: raise MemoryError("Error allocating StatsLevel1") self._owner = None - self._owned = True self._readonly = False def __dealloc__(self): cdef CUfileStatsLevel1_t *ptr - if self._owned and self._ptr != NULL: + if self._owner is None and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) @@ -1579,12 +1565,13 @@ cdef class StatsLevel1: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner is None and self._ptr != NULL: + _cyb_free(self._ptr) self._ptr = _cyb_malloc(sizeof(CUfileStatsLevel1_t)) if self._ptr == NULL: raise MemoryError("Error allocating StatsLevel1") _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(CUfileStatsLevel1_t)) self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -2115,11 +2102,9 @@ cdef class StatsLevel1: raise MemoryError("Error allocating StatsLevel1") _cyb_memcpy((obj._ptr), ptr, sizeof(CUfileStatsLevel1_t)) obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -2335,7 +2320,6 @@ cdef class StatsLevel2: cdef: CUfileStatsLevel2_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): @@ -2343,12 +2327,11 @@ cdef class StatsLevel2: if self._ptr == NULL: raise MemoryError("Error allocating StatsLevel2") self._owner = None - self._owned = True self._readonly = False def __dealloc__(self): cdef CUfileStatsLevel2_t *ptr - if self._owned and self._ptr != NULL: + if self._owner is None and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) @@ -2382,12 +2365,13 @@ cdef class StatsLevel2: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner is None and self._ptr != NULL: + _cyb_free(self._ptr) self._ptr = _cyb_malloc(sizeof(CUfileStatsLevel2_t)) if self._ptr == NULL: raise MemoryError("Error allocating StatsLevel2") _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(CUfileStatsLevel2_t)) self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -2470,11 +2454,9 @@ cdef class StatsLevel2: raise MemoryError("Error allocating StatsLevel2") _cyb_memcpy((obj._ptr), ptr, sizeof(CUfileStatsLevel2_t)) obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -2501,26 +2483,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 +2522,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 +2593,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..8bae11c66c 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=e1e14a18489c6f4d6237962f9c42660e9b656f46a4cc8ab3fa766550419b264c # <<<< PREAMBLE CONTENT >>>> @@ -2189,26 +2189,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 +2228,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 +2365,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 @@ -2420,7 +2403,6 @@ cdef class PciInfo: cdef: nvmlPciInfo_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): @@ -2428,12 +2410,11 @@ cdef class PciInfo: if self._ptr == NULL: raise MemoryError("Error allocating PciInfo") self._owner = None - self._owned = True self._readonly = False def __dealloc__(self): cdef nvmlPciInfo_t *ptr - if self._owned and self._ptr != NULL: + if self._owner is None and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) @@ -2467,12 +2448,13 @@ cdef class PciInfo: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner is None and self._ptr != NULL: + _cyb_free(self._ptr) self._ptr = _cyb_malloc(sizeof(nvmlPciInfo_t)) if self._ptr == NULL: raise MemoryError("Error allocating PciInfo") _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlPciInfo_t)) self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -2594,11 +2576,9 @@ cdef class PciInfo: raise MemoryError("Error allocating PciInfo") _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlPciInfo_t)) obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -2624,26 +2604,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 +2643,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 +2699,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 +2731,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 +2770,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 +2837,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 +2871,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 +2910,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 +2999,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 +3031,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 +3070,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 +3137,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 +3541,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 +3580,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 +3713,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 +3743,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 +3782,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 +3827,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 +3861,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 +3900,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 +3989,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 @@ -4313,7 +4174,6 @@ cdef class Value: cdef: nvmlValue_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): @@ -4321,12 +4181,11 @@ cdef class Value: if self._ptr == NULL: raise MemoryError("Error allocating Value") self._owner = None - self._owned = True self._readonly = False def __dealloc__(self): cdef nvmlValue_t *ptr - if self._owned and self._ptr != NULL: + if self._owner is None and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) @@ -4360,12 +4219,13 @@ cdef class Value: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner is None and self._ptr != NULL: + _cyb_free(self._ptr) self._ptr = _cyb_malloc(sizeof(nvmlValue_t)) if self._ptr == NULL: raise MemoryError("Error allocating Value") _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlValue_t)) self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -4479,11 +4339,9 @@ cdef class Value: raise MemoryError("Error allocating Value") _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlValue_t)) obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -4514,7 +4372,6 @@ cdef class _py_anon_pod0: cdef: cuda_bindings_nvml__anon_pod0 *_ptr object _owner - bint _owned bint _readonly def __init__(self): @@ -4522,12 +4379,11 @@ cdef class _py_anon_pod0: if self._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod0") self._owner = None - self._owned = True self._readonly = False def __dealloc__(self): cdef cuda_bindings_nvml__anon_pod0 *ptr - if self._owned and self._ptr != NULL: + if self._owner is None and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) @@ -4561,12 +4417,13 @@ cdef class _py_anon_pod0: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner is None and self._ptr != NULL: + _cyb_free(self._ptr) 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._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -4658,11 +4515,9 @@ cdef class _py_anon_pod0: raise MemoryError("Error allocating _py_anon_pod0") _cyb_memcpy((obj._ptr), ptr, sizeof(cuda_bindings_nvml__anon_pod0)) obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -4690,26 +4545,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 +4584,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 +4662,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 +4850,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 +4889,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 +4989,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 +5457,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 +5496,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 +5673,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 +5710,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 +5749,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 +5883,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 +5920,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 +5959,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 +6093,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 @@ -6358,7 +6128,6 @@ cdef class _py_anon_pod1: cdef: cuda_bindings_nvml__anon_pod1 *_ptr object _owner - bint _owned bint _readonly def __init__(self): @@ -6366,12 +6135,11 @@ cdef class _py_anon_pod1: if self._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod1") self._owner = None - self._owned = True self._readonly = False def __dealloc__(self): cdef cuda_bindings_nvml__anon_pod1 *ptr - if self._owned and self._ptr != NULL: + if self._owner is None and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) @@ -6405,12 +6173,13 @@ cdef class _py_anon_pod1: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner is None and self._ptr != NULL: + _cyb_free(self._ptr) 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._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -6491,11 +6260,9 @@ cdef class _py_anon_pod1: raise MemoryError("Error allocating _py_anon_pod1") _cyb_memcpy((obj._ptr), ptr, sizeof(cuda_bindings_nvml__anon_pod1)) obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -6524,28 +6291,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 +6332,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 +6418,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 +6450,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 +6489,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 +6545,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 @@ -7092,7 +6825,6 @@ cdef class _py_anon_pod2: cdef: cuda_bindings_nvml__anon_pod2 *_ptr object _owner - bint _owned bint _readonly def __init__(self): @@ -7100,12 +6832,11 @@ cdef class _py_anon_pod2: if self._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod2") self._owner = None - self._owned = True self._readonly = False def __dealloc__(self): cdef cuda_bindings_nvml__anon_pod2 *ptr - if self._owned and self._ptr != NULL: + if self._owner is None and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) @@ -7139,12 +6870,13 @@ cdef class _py_anon_pod2: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner is None and self._ptr != NULL: + _cyb_free(self._ptr) self._ptr = _cyb_malloc(sizeof(cuda_bindings_nvml__anon_pod2)) if self._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod2") _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(cuda_bindings_nvml__anon_pod2)) self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -7203,11 +6935,9 @@ cdef class _py_anon_pod2: raise MemoryError("Error allocating _py_anon_pod2") _cyb_memcpy((obj._ptr), ptr, sizeof(cuda_bindings_nvml__anon_pod2)) obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -7234,7 +6964,6 @@ cdef class _py_anon_pod3: cdef: cuda_bindings_nvml__anon_pod3 *_ptr object _owner - bint _owned bint _readonly def __init__(self): @@ -7242,12 +6971,11 @@ cdef class _py_anon_pod3: if self._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod3") self._owner = None - self._owned = True self._readonly = False def __dealloc__(self): cdef cuda_bindings_nvml__anon_pod3 *ptr - if self._owned and self._ptr != NULL: + if self._owner is None and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) @@ -7281,12 +7009,13 @@ cdef class _py_anon_pod3: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner is None and self._ptr != NULL: + _cyb_free(self._ptr) self._ptr = _cyb_malloc(sizeof(cuda_bindings_nvml__anon_pod3)) if self._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod3") _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(cuda_bindings_nvml__anon_pod3)) self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -7334,11 +7063,9 @@ cdef class _py_anon_pod3: raise MemoryError("Error allocating _py_anon_pod3") _cyb_memcpy((obj._ptr), ptr, sizeof(cuda_bindings_nvml__anon_pod3)) obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -7567,7 +7294,6 @@ cdef class _py_anon_pod4: cdef: cuda_bindings_nvml__anon_pod4 *_ptr object _owner - bint _owned bint _readonly def __init__(self): @@ -7575,12 +7301,11 @@ cdef class _py_anon_pod4: if self._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod4") self._owner = None - self._owned = True self._readonly = False def __dealloc__(self): cdef cuda_bindings_nvml__anon_pod4 *ptr - if self._owned and self._ptr != NULL: + if self._owner is None and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) @@ -7614,12 +7339,13 @@ cdef class _py_anon_pod4: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner is None and self._ptr != NULL: + _cyb_free(self._ptr) self._ptr = _cyb_malloc(sizeof(cuda_bindings_nvml__anon_pod4)) if self._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod4") _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(cuda_bindings_nvml__anon_pod4)) self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -7678,11 +7404,9 @@ cdef class _py_anon_pod4: raise MemoryError("Error allocating _py_anon_pod4") _cyb_memcpy((obj._ptr), ptr, sizeof(cuda_bindings_nvml__anon_pod4)) obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -7709,7 +7433,6 @@ cdef class _py_anon_pod5: cdef: cuda_bindings_nvml__anon_pod5 *_ptr object _owner - bint _owned bint _readonly def __init__(self): @@ -7717,12 +7440,11 @@ cdef class _py_anon_pod5: if self._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod5") self._owner = None - self._owned = True self._readonly = False def __dealloc__(self): cdef cuda_bindings_nvml__anon_pod5 *ptr - if self._owned and self._ptr != NULL: + if self._owner is None and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) @@ -7756,12 +7478,13 @@ cdef class _py_anon_pod5: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner is None and self._ptr != NULL: + _cyb_free(self._ptr) self._ptr = _cyb_malloc(sizeof(cuda_bindings_nvml__anon_pod5)) if self._ptr == NULL: raise MemoryError("Error allocating _py_anon_pod5") _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(cuda_bindings_nvml__anon_pod5)) self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -7809,11 +7532,9 @@ cdef class _py_anon_pod5: raise MemoryError("Error allocating _py_anon_pod5") _cyb_memcpy((obj._ptr), ptr, sizeof(cuda_bindings_nvml__anon_pod5)) obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -7845,26 +7566,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 +7605,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 +7733,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 @@ -8067,7 +7771,6 @@ cdef class VgpuLicenseExpiry: cdef: nvmlVgpuLicenseExpiry_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): @@ -8075,12 +7778,11 @@ cdef class VgpuLicenseExpiry: if self._ptr == NULL: raise MemoryError("Error allocating VgpuLicenseExpiry") self._owner = None - self._owned = True self._readonly = False def __dealloc__(self): cdef nvmlVgpuLicenseExpiry_t *ptr - if self._owned and self._ptr != NULL: + if self._owner is None and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) @@ -8114,12 +7816,13 @@ cdef class VgpuLicenseExpiry: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner is None and self._ptr != NULL: + _cyb_free(self._ptr) self._ptr = _cyb_malloc(sizeof(nvmlVgpuLicenseExpiry_t)) if self._ptr == NULL: raise MemoryError("Error allocating VgpuLicenseExpiry") _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlVgpuLicenseExpiry_t)) self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -8233,11 +7936,9 @@ cdef class VgpuLicenseExpiry: raise MemoryError("Error allocating VgpuLicenseExpiry") _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlVgpuLicenseExpiry_t)) obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -8270,7 +7971,6 @@ cdef class GridLicenseExpiry: cdef: nvmlGridLicenseExpiry_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): @@ -8278,12 +7978,11 @@ cdef class GridLicenseExpiry: if self._ptr == NULL: raise MemoryError("Error allocating GridLicenseExpiry") self._owner = None - self._owned = True self._readonly = False def __dealloc__(self): cdef nvmlGridLicenseExpiry_t *ptr - if self._owned and self._ptr != NULL: + if self._owner is None and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) @@ -8317,12 +8016,13 @@ cdef class GridLicenseExpiry: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner is None and self._ptr != NULL: + _cyb_free(self._ptr) self._ptr = _cyb_malloc(sizeof(nvmlGridLicenseExpiry_t)) if self._ptr == NULL: raise MemoryError("Error allocating GridLicenseExpiry") _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlGridLicenseExpiry_t)) self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -8436,11 +8136,9 @@ cdef class GridLicenseExpiry: raise MemoryError("Error allocating GridLicenseExpiry") _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlGridLicenseExpiry_t)) obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -8467,28 +8165,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 +8206,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 +8270,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 +8303,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 +8344,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 +8408,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 +8443,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 +8484,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 +8570,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 +8753,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 +8792,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 +8852,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 +8885,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 +8924,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 +9018,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 +9051,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 +9090,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 +9172,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 +9359,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 +9398,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 +9487,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 +9676,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 +9715,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 +9815,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 +10072,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 +10111,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 +10178,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 +10482,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 +10521,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 +10577,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 +10609,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 +10648,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 +10715,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 +10749,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 +10788,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 +10877,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 +10908,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 +10947,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 +11003,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 +11036,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 +11075,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 +11153,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 +11188,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 +11227,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 +11333,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 +11368,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 +11407,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 +11513,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 +11545,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 +11584,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 +11651,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 +11683,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 +11722,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 +11789,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 +11821,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 +11860,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 +11927,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 @@ -12585,7 +11960,6 @@ cdef class VgpuVersion: cdef: nvmlVgpuVersion_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): @@ -12593,12 +11967,11 @@ cdef class VgpuVersion: if self._ptr == NULL: raise MemoryError("Error allocating VgpuVersion") self._owner = None - self._owned = True self._readonly = False def __dealloc__(self): cdef nvmlVgpuVersion_t *ptr - if self._owned and self._ptr != NULL: + if self._owner is None and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) @@ -12632,12 +12005,13 @@ cdef class VgpuVersion: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner is None and self._ptr != NULL: + _cyb_free(self._ptr) self._ptr = _cyb_malloc(sizeof(nvmlVgpuVersion_t)) if self._ptr == NULL: raise MemoryError("Error allocating VgpuVersion") _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlVgpuVersion_t)) self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -12696,11 +12070,9 @@ cdef class VgpuVersion: raise MemoryError("Error allocating VgpuVersion") _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlVgpuVersion_t)) obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -12734,26 +12106,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 +12145,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 +12290,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 +12321,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 +12360,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 +12416,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 +12611,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 +12650,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 +12831,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 +13024,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 +13063,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 +13222,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 +13263,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 +13302,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 +13472,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 +13503,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 +13542,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 +13598,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 +13630,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 +13669,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 +13736,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 +13768,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 +13807,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 +13874,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 +14123,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 +14162,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 +14279,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 +14310,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 +14349,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 +14405,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 @@ -15238,7 +14440,6 @@ cdef class NvlinkFirmwareVersion: cdef: nvmlNvlinkFirmwareVersion_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): @@ -15246,12 +14447,11 @@ cdef class NvlinkFirmwareVersion: if self._ptr == NULL: raise MemoryError("Error allocating NvlinkFirmwareVersion") self._owner = None - self._owned = True self._readonly = False def __dealloc__(self): cdef nvmlNvlinkFirmwareVersion_t *ptr - if self._owned and self._ptr != NULL: + if self._owner is None and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) @@ -15285,12 +14485,13 @@ cdef class NvlinkFirmwareVersion: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner is None and self._ptr != NULL: + _cyb_free(self._ptr) 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._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -15371,11 +14572,9 @@ cdef class NvlinkFirmwareVersion: raise MemoryError("Error allocating NvlinkFirmwareVersion") _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlNvlinkFirmwareVersion_t)) obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -15402,7 +14601,6 @@ cdef class PRMCounterInput_v1: cdef: nvmlPRMCounterInput_v1_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): @@ -15410,12 +14608,11 @@ cdef class PRMCounterInput_v1: if self._ptr == NULL: raise MemoryError("Error allocating PRMCounterInput_v1") self._owner = None - self._owned = True self._readonly = False def __dealloc__(self): cdef nvmlPRMCounterInput_v1_t *ptr - if self._owned and self._ptr != NULL: + if self._owner is None and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) @@ -15449,12 +14646,13 @@ cdef class PRMCounterInput_v1: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner is None and self._ptr != NULL: + _cyb_free(self._ptr) self._ptr = _cyb_malloc(sizeof(nvmlPRMCounterInput_v1_t)) if self._ptr == NULL: raise MemoryError("Error allocating PRMCounterInput_v1") _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlPRMCounterInput_v1_t)) self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -15502,11 +14700,9 @@ cdef class PRMCounterInput_v1: raise MemoryError("Error allocating PRMCounterInput_v1") _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlPRMCounterInput_v1_t)) obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -15534,26 +14730,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 +14769,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 +14847,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 +15093,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 +15132,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 +15210,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 +15241,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 +15280,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 +15341,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 +15374,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 +15415,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 +15487,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 +15519,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 +15558,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 +15609,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 @@ -17300,7 +16411,6 @@ cdef class PRMCounterValue_v1: cdef: nvmlPRMCounterValue_v1_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): @@ -17308,12 +16418,11 @@ cdef class PRMCounterValue_v1: if self._ptr == NULL: raise MemoryError("Error allocating PRMCounterValue_v1") self._owner = None - self._owned = True self._readonly = False def __dealloc__(self): cdef nvmlPRMCounterValue_v1_t *ptr - if self._owned and self._ptr != NULL: + if self._owner is None and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) @@ -17347,12 +16456,13 @@ cdef class PRMCounterValue_v1: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner is None and self._ptr != NULL: + _cyb_free(self._ptr) self._ptr = _cyb_malloc(sizeof(nvmlPRMCounterValue_v1_t)) if self._ptr == NULL: raise MemoryError("Error allocating PRMCounterValue_v1") _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlPRMCounterValue_v1_t)) self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -17423,11 +16533,9 @@ cdef class PRMCounterValue_v1: raise MemoryError("Error allocating PRMCounterValue_v1") _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlPRMCounterValue_v1_t)) obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -17453,26 +16561,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 +16600,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 +16659,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 +16691,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 +16730,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 +16792,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 +16825,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 +16866,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 +16938,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 +16970,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 +17009,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 +17068,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 +17101,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 +17142,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 +17214,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 @@ -18219,7 +17242,6 @@ cdef class VgpuSchedulerParams: cdef: nvmlVgpuSchedulerParams_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): @@ -18227,12 +17249,11 @@ cdef class VgpuSchedulerParams: if self._ptr == NULL: raise MemoryError("Error allocating VgpuSchedulerParams") self._owner = None - self._owned = True self._readonly = False def __dealloc__(self): cdef nvmlVgpuSchedulerParams_t *ptr - if self._owned and self._ptr != NULL: + if self._owner is None and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) @@ -18266,12 +17287,13 @@ cdef class VgpuSchedulerParams: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner is None and self._ptr != NULL: + _cyb_free(self._ptr) self._ptr = _cyb_malloc(sizeof(nvmlVgpuSchedulerParams_t)) if self._ptr == NULL: raise MemoryError("Error allocating VgpuSchedulerParams") _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlVgpuSchedulerParams_t)) self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -18332,11 +17354,9 @@ cdef class VgpuSchedulerParams: raise MemoryError("Error allocating VgpuSchedulerParams") _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlVgpuSchedulerParams_t)) obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -18358,7 +17378,6 @@ cdef class VgpuSchedulerSetParams: cdef: nvmlVgpuSchedulerSetParams_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): @@ -18366,12 +17385,11 @@ cdef class VgpuSchedulerSetParams: if self._ptr == NULL: raise MemoryError("Error allocating VgpuSchedulerSetParams") self._owner = None - self._owned = True self._readonly = False def __dealloc__(self): cdef nvmlVgpuSchedulerSetParams_t *ptr - if self._owned and self._ptr != NULL: + if self._owner is None and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) @@ -18405,12 +17423,13 @@ cdef class VgpuSchedulerSetParams: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner is None and self._ptr != NULL: + _cyb_free(self._ptr) self._ptr = _cyb_malloc(sizeof(nvmlVgpuSchedulerSetParams_t)) if self._ptr == NULL: raise MemoryError("Error allocating VgpuSchedulerSetParams") _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlVgpuSchedulerSetParams_t)) self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -18471,11 +17490,9 @@ cdef class VgpuSchedulerSetParams: raise MemoryError("Error allocating VgpuSchedulerSetParams") _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlVgpuSchedulerSetParams_t)) obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -18502,26 +17519,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 +17558,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 +17626,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 +17852,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 +17891,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 +17950,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 +17987,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 +18026,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 +18146,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 +18179,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 +18218,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 +18297,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 +18331,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 +18370,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 +18460,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 +18492,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 +18533,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 +18594,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 @@ -19713,7 +18628,6 @@ cdef class NvlinkFirmwareInfo: cdef: nvmlNvlinkFirmwareInfo_t *_ptr object _owner - bint _owned bint _readonly def __init__(self): @@ -19721,12 +18635,11 @@ cdef class NvlinkFirmwareInfo: if self._ptr == NULL: raise MemoryError("Error allocating NvlinkFirmwareInfo") self._owner = None - self._owned = True self._readonly = False def __dealloc__(self): cdef nvmlNvlinkFirmwareInfo_t *ptr - if self._owned and self._ptr != NULL: + if self._owner is None and self._ptr != NULL: ptr = self._ptr self._ptr = NULL _cyb_free(ptr) @@ -19760,12 +18673,13 @@ cdef class NvlinkFirmwareInfo: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): + if self._owner is None and self._ptr != NULL: + _cyb_free(self._ptr) self._ptr = _cyb_malloc(sizeof(nvmlNvlinkFirmwareInfo_t)) if self._ptr == NULL: raise MemoryError("Error allocating NvlinkFirmwareInfo") _cyb_memcpy(self._ptr, val.ctypes.data, sizeof(nvmlNvlinkFirmwareInfo_t)) self._owner = None - self._owned = True self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -19827,11 +18741,9 @@ cdef class NvlinkFirmwareInfo: raise MemoryError("Error allocating NvlinkFirmwareInfo") _cyb_memcpy((obj._ptr), ptr, sizeof(nvmlNvlinkFirmwareInfo_t)) obj._owner = None - obj._owned = True else: obj._ptr = ptr obj._owner = owner - obj._owned = False obj._readonly = readonly return obj @@ -19861,26 +18773,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 +18812,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 +18915,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 +18949,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 +18990,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 +19073,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 +19270,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 +19309,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 +19413,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 +19445,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 +19484,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 +19552,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 +19586,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 +19625,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 +19715,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 +19751,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 +19790,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 +19905,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 +19939,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 +19978,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 +20068,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 +20100,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 +20139,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 +20201,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 +20233,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 +20272,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 +20340,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 From 4c5db36af1a47831c31bc40d06dc1133f216aec8 Mon Sep 17 00:00:00 2001 From: Michael Droettboom Date: Fri, 17 Jul 2026 09:51:02 -0400 Subject: [PATCH 2/2] Bugfix PyObject handling --- cuda_bindings/cuda/bindings/cufile.pyx | 115 +++++---- cuda_bindings/cuda/bindings/nvml.pyx | 313 +++++++++++++++---------- 2 files changed, 265 insertions(+), 163 deletions(-) diff --git a/cuda_bindings/cuda/bindings/cufile.pyx b/cuda_bindings/cuda/bindings/cufile.pyx index cbe11968d8..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=6a92dc0345783c19c92a86ab536639223cf0274bbb87877f7e4ac43b2e949053 +# 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,22 +101,24 @@ cdef class _py_anon_pod1: """ cdef: cuda_bindings_cufile__anon_pod1 *_ptr - object _owner + _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._owner = NULL self._readonly = False def __dealloc__(self): cdef cuda_bindings_cufile__anon_pod1 *ptr - if self._owner is None 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))}>" @@ -142,13 +149,14 @@ cdef class _py_anon_pod1: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): - if self._owner is None and self._ptr != NULL: + 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -206,10 +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._owner = NULL else: obj._ptr = ptr - obj._owner = owner + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -238,22 +247,24 @@ cdef class _py_anon_pod3: """ cdef: cuda_bindings_cufile__anon_pod3 *_ptr - object _owner + _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._owner = NULL self._readonly = False def __dealloc__(self): cdef cuda_bindings_cufile__anon_pod3 *ptr - if self._owner is None 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))}>" @@ -284,13 +295,14 @@ cdef class _py_anon_pod3: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): - if self._owner is None and self._ptr != NULL: + 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -370,10 +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._owner = NULL else: obj._ptr = ptr - obj._owner = owner + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -565,22 +578,24 @@ cdef class OpCounter: """ cdef: CUfileOpCounter_t *_ptr - object _owner + _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._owner = NULL self._readonly = False def __dealloc__(self): cdef CUfileOpCounter_t *ptr - if self._owner is None 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))}>" @@ -611,13 +626,14 @@ cdef class OpCounter: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): - if self._owner is None and self._ptr != NULL: + 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -675,10 +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._owner = NULL else: obj._ptr = ptr - obj._owner = owner + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -1348,22 +1365,24 @@ cdef class _py_anon_pod2: """ cdef: cuda_bindings_cufile__anon_pod2 *_ptr - object _owner + _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._owner = NULL self._readonly = False def __dealloc__(self): cdef cuda_bindings_cufile__anon_pod2 *ptr - if self._owner is None 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))}>" @@ -1394,13 +1413,14 @@ cdef class _py_anon_pod2: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): - if self._owner is None and self._ptr != NULL: + 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -1448,10 +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._owner = NULL else: obj._ptr = ptr - obj._owner = owner + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -1519,22 +1540,24 @@ cdef class StatsLevel1: """ cdef: CUfileStatsLevel1_t *_ptr - object _owner + _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._owner = NULL self._readonly = False def __dealloc__(self): cdef CUfileStatsLevel1_t *ptr - if self._owner is None 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))}>" @@ -1565,13 +1588,14 @@ cdef class StatsLevel1: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): - if self._owner is None and self._ptr != NULL: + 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -2101,10 +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._owner = NULL else: obj._ptr = ptr - obj._owner = owner + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -2319,22 +2344,24 @@ cdef class StatsLevel2: """ cdef: CUfileStatsLevel2_t *_ptr - object _owner + _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._owner = NULL self._readonly = False def __dealloc__(self): cdef CUfileStatsLevel2_t *ptr - if self._owner is None 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))}>" @@ -2365,13 +2392,14 @@ cdef class StatsLevel2: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): - if self._owner is None and self._ptr != NULL: + 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -2453,10 +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._owner = NULL else: obj._ptr = ptr - obj._owner = owner + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj diff --git a/cuda_bindings/cuda/bindings/nvml.pyx b/cuda_bindings/cuda/bindings/nvml.pyx index 8bae11c66c..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=e1e14a18489c6f4d6237962f9c42660e9b656f46a4cc8ab3fa766550419b264c +# 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, @@ -2402,22 +2407,24 @@ cdef class PciInfo: """ cdef: nvmlPciInfo_t *_ptr - object _owner + _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._owner = NULL self._readonly = False def __dealloc__(self): cdef nvmlPciInfo_t *ptr - if self._owner is None 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))}>" @@ -2448,13 +2455,14 @@ cdef class PciInfo: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): - if self._owner is None and self._ptr != NULL: + 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -2575,10 +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._owner = NULL else: obj._ptr = ptr - obj._owner = owner + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -4173,22 +4182,24 @@ cdef class Value: """ cdef: nvmlValue_t *_ptr - object _owner + _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._owner = NULL self._readonly = False def __dealloc__(self): cdef nvmlValue_t *ptr - if self._owner is None 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))}>" @@ -4219,13 +4230,14 @@ cdef class Value: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): - if self._owner is None and self._ptr != NULL: + 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -4338,10 +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._owner = NULL else: obj._ptr = ptr - obj._owner = owner + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -4371,22 +4384,24 @@ cdef class _py_anon_pod0: """ cdef: cuda_bindings_nvml__anon_pod0 *_ptr - object _owner + _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._owner = NULL self._readonly = False def __dealloc__(self): cdef cuda_bindings_nvml__anon_pod0 *ptr - if self._owner is None 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))}>" @@ -4417,13 +4432,14 @@ cdef class _py_anon_pod0: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): - if self._owner is None and self._ptr != NULL: + 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -4514,10 +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._owner = NULL else: obj._ptr = ptr - obj._owner = owner + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -6127,22 +6144,24 @@ cdef class _py_anon_pod1: """ cdef: cuda_bindings_nvml__anon_pod1 *_ptr - object _owner + _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._owner = NULL self._readonly = False def __dealloc__(self): cdef cuda_bindings_nvml__anon_pod1 *ptr - if self._owner is None 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))}>" @@ -6173,13 +6192,14 @@ cdef class _py_anon_pod1: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): - if self._owner is None and self._ptr != NULL: + 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -6259,10 +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._owner = NULL else: obj._ptr = ptr - obj._owner = owner + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -6824,22 +6845,24 @@ cdef class _py_anon_pod2: """ cdef: cuda_bindings_nvml__anon_pod2 *_ptr - object _owner + _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._owner = NULL self._readonly = False def __dealloc__(self): cdef cuda_bindings_nvml__anon_pod2 *ptr - if self._owner is None 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))}>" @@ -6870,13 +6893,14 @@ cdef class _py_anon_pod2: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): - if self._owner is None and self._ptr != NULL: + 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -6934,10 +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._owner = NULL else: obj._ptr = ptr - obj._owner = owner + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -6963,22 +6988,24 @@ cdef class _py_anon_pod3: """ cdef: cuda_bindings_nvml__anon_pod3 *_ptr - object _owner + _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._owner = NULL self._readonly = False def __dealloc__(self): cdef cuda_bindings_nvml__anon_pod3 *ptr - if self._owner is None 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))}>" @@ -7009,13 +7036,14 @@ cdef class _py_anon_pod3: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): - if self._owner is None and self._ptr != NULL: + 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -7062,10 +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._owner = NULL else: obj._ptr = ptr - obj._owner = owner + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -7293,22 +7322,24 @@ cdef class _py_anon_pod4: """ cdef: cuda_bindings_nvml__anon_pod4 *_ptr - object _owner + _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._owner = NULL self._readonly = False def __dealloc__(self): cdef cuda_bindings_nvml__anon_pod4 *ptr - if self._owner is None 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))}>" @@ -7339,13 +7370,14 @@ cdef class _py_anon_pod4: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): - if self._owner is None and self._ptr != NULL: + 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -7403,10 +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._owner = NULL else: obj._ptr = ptr - obj._owner = owner + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -7432,22 +7465,24 @@ cdef class _py_anon_pod5: """ cdef: cuda_bindings_nvml__anon_pod5 *_ptr - object _owner + _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._owner = NULL self._readonly = False def __dealloc__(self): cdef cuda_bindings_nvml__anon_pod5 *ptr - if self._owner is None 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))}>" @@ -7478,13 +7513,14 @@ cdef class _py_anon_pod5: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): - if self._owner is None and self._ptr != NULL: + 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -7531,10 +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._owner = NULL else: obj._ptr = ptr - obj._owner = owner + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -7770,22 +7807,24 @@ cdef class VgpuLicenseExpiry: """ cdef: nvmlVgpuLicenseExpiry_t *_ptr - object _owner + _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._owner = NULL self._readonly = False def __dealloc__(self): cdef nvmlVgpuLicenseExpiry_t *ptr - if self._owner is None 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))}>" @@ -7816,13 +7855,14 @@ cdef class VgpuLicenseExpiry: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): - if self._owner is None and self._ptr != NULL: + 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -7935,10 +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._owner = NULL else: obj._ptr = ptr - obj._owner = owner + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -7970,22 +8011,24 @@ cdef class GridLicenseExpiry: """ cdef: nvmlGridLicenseExpiry_t *_ptr - object _owner + _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._owner = NULL self._readonly = False def __dealloc__(self): cdef nvmlGridLicenseExpiry_t *ptr - if self._owner is None 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))}>" @@ -8016,13 +8059,14 @@ cdef class GridLicenseExpiry: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): - if self._owner is None and self._ptr != NULL: + 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -8135,10 +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._owner = NULL else: obj._ptr = ptr - obj._owner = owner + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -11959,22 +12004,24 @@ cdef class VgpuVersion: """ cdef: nvmlVgpuVersion_t *_ptr - object _owner + _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._owner = NULL self._readonly = False def __dealloc__(self): cdef nvmlVgpuVersion_t *ptr - if self._owner is None 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))}>" @@ -12005,13 +12052,14 @@ cdef class VgpuVersion: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): - if self._owner is None and self._ptr != NULL: + 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -12069,10 +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._owner = NULL else: obj._ptr = ptr - obj._owner = owner + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -14439,22 +14488,24 @@ cdef class NvlinkFirmwareVersion: """ cdef: nvmlNvlinkFirmwareVersion_t *_ptr - object _owner + _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._owner = NULL self._readonly = False def __dealloc__(self): cdef nvmlNvlinkFirmwareVersion_t *ptr - if self._owner is None 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))}>" @@ -14485,13 +14536,14 @@ cdef class NvlinkFirmwareVersion: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): - if self._owner is None and self._ptr != NULL: + 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -14571,10 +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._owner = NULL else: obj._ptr = ptr - obj._owner = owner + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -14600,22 +14653,24 @@ cdef class PRMCounterInput_v1: """ cdef: nvmlPRMCounterInput_v1_t *_ptr - object _owner + _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._owner = NULL self._readonly = False def __dealloc__(self): cdef nvmlPRMCounterInput_v1_t *ptr - if self._owner is None 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))}>" @@ -14646,13 +14701,14 @@ cdef class PRMCounterInput_v1: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): - if self._owner is None and self._ptr != NULL: + 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -14699,10 +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._owner = NULL else: obj._ptr = ptr - obj._owner = owner + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -16410,22 +16467,24 @@ cdef class PRMCounterValue_v1: """ cdef: nvmlPRMCounterValue_v1_t *_ptr - object _owner + _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._owner = NULL self._readonly = False def __dealloc__(self): cdef nvmlPRMCounterValue_v1_t *ptr - if self._owner is None 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))}>" @@ -16456,13 +16515,14 @@ cdef class PRMCounterValue_v1: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): - if self._owner is None and self._ptr != NULL: + 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -16532,10 +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._owner = NULL else: obj._ptr = ptr - obj._owner = owner + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -17241,22 +17302,24 @@ cdef class VgpuSchedulerParams: """ cdef: nvmlVgpuSchedulerParams_t *_ptr - object _owner + _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._owner = NULL self._readonly = False def __dealloc__(self): cdef nvmlVgpuSchedulerParams_t *ptr - if self._owner is None 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))}>" @@ -17287,13 +17350,14 @@ cdef class VgpuSchedulerParams: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): - if self._owner is None and self._ptr != NULL: + 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -17353,10 +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._owner = NULL else: obj._ptr = ptr - obj._owner = owner + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -17377,22 +17442,24 @@ cdef class VgpuSchedulerSetParams: """ cdef: nvmlVgpuSchedulerSetParams_t *_ptr - object _owner + _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._owner = NULL self._readonly = False def __dealloc__(self): cdef nvmlVgpuSchedulerSetParams_t *ptr - if self._owner is None 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))}>" @@ -17423,13 +17490,14 @@ cdef class VgpuSchedulerSetParams: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): - if self._owner is None and self._ptr != NULL: + 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -17489,10 +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._owner = NULL else: obj._ptr = ptr - obj._owner = owner + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj @@ -18627,22 +18696,24 @@ cdef class NvlinkFirmwareInfo: """ cdef: nvmlNvlinkFirmwareInfo_t *_ptr - object _owner + _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._owner = NULL self._readonly = False def __dealloc__(self): cdef nvmlNvlinkFirmwareInfo_t *ptr - if self._owner is None 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))}>" @@ -18673,13 +18744,14 @@ cdef class NvlinkFirmwareInfo: def __setitem__(self, key, val): if key == 0 and isinstance(val, _numpy.ndarray): - if self._owner is None and self._ptr != NULL: + 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._owner = NULL self._readonly = not val.flags.writeable else: setattr(self, key, val) @@ -18740,10 +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._owner = NULL else: obj._ptr = ptr - obj._owner = owner + obj._owner = <_cyb_PyObject *>owner + _cyb_Py_XINCREF(obj._owner) obj._readonly = readonly return obj