diff --git a/cuda_bindings_13/cuda/bindings/_internal/cudla_linux.pyx b/cuda_bindings_13/cuda/bindings/_internal/cudla_linux.pyx index b9cbb73a32e..1624403751a 100644 --- a/cuda_bindings_13/cuda/bindings/_internal/cudla_linux.pyx +++ b/cuda_bindings_13/cuda/bindings/_internal/cudla_linux.pyx @@ -2,11 +2,18 @@ # SPDX-License-Identifier: Apache-2.0 # This code was automatically generated across versions from 1.5.0 to 13.4.1. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=6d02d71c7a7ef7627a3dccc1514b8e1ea48ac7d738954a2259df71cfeaaca839 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=c45f2cb738d8336a435dae2e5398dc561e360788ee832d40c684a2e17515ae47 # <<<< PREAMBLE CONTENT >>>> +from libc.stdint cimport ( + intptr_t, + uint32_t, + uint64_t, + uint8_t, +) + cdef extern from * nogil: """ #if defined(_MSC_VER) && !defined(__clang__) @@ -43,13 +50,6 @@ cdef extern from "": void* _cyb_dlsym "dlsym"(void*, const char*) nogil const void * _cyb_RTLD_DEFAULT "RTLD_DEFAULT" -from libc.stdint cimport ( - intptr_t, - uint32_t, - uint64_t, - uint8_t, -) - import threading as _cyb_threading cdef int _cyb___py_cudla_init = 0 diff --git a/cuda_bindings_13/cuda/bindings/_internal/cudla_windows.pyx b/cuda_bindings_13/cuda/bindings/_internal/cudla_windows.pyx index 8e361068068..a7e8da22d80 100644 --- a/cuda_bindings_13/cuda/bindings/_internal/cudla_windows.pyx +++ b/cuda_bindings_13/cuda/bindings/_internal/cudla_windows.pyx @@ -2,11 +2,19 @@ # SPDX-License-Identifier: Apache-2.0 # This code was automatically generated across versions from 1.5.0 to 13.4.1. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=338d2b3b3dc670ce440660d6161d69bb61b7c2f0c03759fa8df5c91d45255d7d +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=23ad0c59749e78f838cc290fb24960736dbdaceca13f2c6544ba4e0732c23cde # <<<< PREAMBLE CONTENT >>>> +from libc.stdint cimport ( + intptr_t, + uint32_t, + uint64_t, + uint8_t, + uintptr_t, +) + cdef extern from * nogil: """ #if defined(_MSC_VER) && !defined(__clang__) @@ -43,14 +51,6 @@ cdef extern from "": ctypedef void* HMODULE void* _cyb_GetProcAddress "GetProcAddress"(HMODULE, const char*) nogil -from libc.stdint cimport ( - intptr_t, - uint32_t, - uint64_t, - uint8_t, - uintptr_t, -) - import threading as _cyb_threading cdef int _cyb___py_cudla_init = 0 diff --git a/cuda_bindings_13/cuda/bindings/_internal/cufile_linux.pyx b/cuda_bindings_13/cuda/bindings/_internal/cufile_linux.pyx index 03864ddd836..7c1217c6c59 100644 --- a/cuda_bindings_13/cuda/bindings/_internal/cufile_linux.pyx +++ b/cuda_bindings_13/cuda/bindings/_internal/cufile_linux.pyx @@ -3,11 +3,15 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.1 to 13.4.1. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=20df7b33c9628ffefdce815bf9ffa31e635a9410ef0156145ced38a6e092d7f1 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=38e48c1ea5af3be92228b849ae38423ddcf662dc7c50d1bf8fea3e01a5b05f71 # <<<< PREAMBLE CONTENT >>>> +cimport cython as _cyb_cython +from libc.stdint cimport intptr_t +from libcpp cimport bool as _cyb_bool + cdef extern from * nogil: """ #if defined(_MSC_VER) && !defined(__clang__) @@ -44,10 +48,6 @@ cdef extern from "": void* _cyb_dlsym "dlsym"(void*, const char*) nogil const void * _cyb_RTLD_DEFAULT "RTLD_DEFAULT" -cimport cython as _cyb_cython -from libc.stdint cimport intptr_t -from libcpp cimport bool as _cyb_bool - import threading as _cyb_threading cdef int _cyb___py_cufile_init = 0 diff --git a/cuda_bindings_13/cuda/bindings/_internal/driver_linux.pyx b/cuda_bindings_13/cuda/bindings/_internal/driver_linux.pyx index 59d14f75b9e..ced9445af82 100644 --- a/cuda_bindings_13/cuda/bindings/_internal/driver_linux.pyx +++ b/cuda_bindings_13/cuda/bindings/_internal/driver_linux.pyx @@ -3,11 +3,13 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.0 to 13.4.1. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=c6a477ceb1a35675c0ffe5e40f9826ea3e3bd9cbec23720f78fe4cf28feafbe0 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=cf88d68f5d0521e0872350a3e27b7c90b33d32c0d3d1211ae1aa746da98a588d # <<<< PREAMBLE CONTENT >>>> +from libc.stdint cimport intptr_t + cdef extern from * nogil: """ #if defined(_MSC_VER) && !defined(__clang__) @@ -43,8 +45,6 @@ cdef extern from * nogil: cdef extern from "": void* _cyb_dlsym "dlsym"(void*, const char*) nogil -from libc.stdint cimport intptr_t - from os import getenv as _cyb_getenv import threading as _cyb_threading diff --git a/cuda_bindings_13/cuda/bindings/_internal/driver_windows.pyx b/cuda_bindings_13/cuda/bindings/_internal/driver_windows.pyx index 3d298bc3ba1..eb27c475ed8 100644 --- a/cuda_bindings_13/cuda/bindings/_internal/driver_windows.pyx +++ b/cuda_bindings_13/cuda/bindings/_internal/driver_windows.pyx @@ -3,11 +3,13 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.0 to 13.4.1. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=a04dbfec5a461010c493b3aca0b092910ff3eb49d31942a68c957309892b2aa6 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=407fc621da7a0e722426cccfd66003e6769c32bc671f8ff28cf6fe979ed11b1a # <<<< PREAMBLE CONTENT >>>> +from libc.stdint cimport intptr_t + cdef extern from * nogil: """ #if defined(_MSC_VER) && !defined(__clang__) @@ -44,8 +46,6 @@ cdef extern from "": ctypedef void* HMODULE void* _cyb_GetProcAddress "GetProcAddress"(HMODULE, const char*) nogil -from libc.stdint cimport intptr_t - from os import getenv as _cyb_getenv import threading as _cyb_threading diff --git a/cuda_bindings_13/cuda/bindings/_internal/nvfatbin_linux.pyx b/cuda_bindings_13/cuda/bindings/_internal/nvfatbin_linux.pyx index 937878b5a15..37250984d38 100644 --- a/cuda_bindings_13/cuda/bindings/_internal/nvfatbin_linux.pyx +++ b/cuda_bindings_13/cuda/bindings/_internal/nvfatbin_linux.pyx @@ -3,11 +3,13 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.4.1 to 13.4.1. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=6b42b70b945f3898a53f87261fcdb5a688cb9ab93476427781e1838a3ffffaf9 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=4bf2730251b3d81162f91091cba3d7fbb1d95f8a7e5b74f5957c39ac47d22eff # <<<< PREAMBLE CONTENT >>>> +from libc.stdint cimport intptr_t + cdef extern from * nogil: """ #if defined(_MSC_VER) && !defined(__clang__) @@ -44,8 +46,6 @@ cdef extern from "": void* _cyb_dlsym "dlsym"(void*, const char*) nogil const void * _cyb_RTLD_DEFAULT "RTLD_DEFAULT" -from libc.stdint cimport intptr_t - import threading as _cyb_threading cdef int _cyb___py_nvfatbin_init = 0 diff --git a/cuda_bindings_13/cuda/bindings/_internal/nvfatbin_windows.pyx b/cuda_bindings_13/cuda/bindings/_internal/nvfatbin_windows.pyx index 03453560c4e..1e418bec4e6 100644 --- a/cuda_bindings_13/cuda/bindings/_internal/nvfatbin_windows.pyx +++ b/cuda_bindings_13/cuda/bindings/_internal/nvfatbin_windows.pyx @@ -3,11 +3,16 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.4.1 to 13.4.1. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=4f4711d1bf4600663e9a7958c75666ad7c7785248afdef1c701d58c78ce81bfe +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=a3224a93fd799648bec24b3ed8b1e81c8eeff581fef9060f812e8d299c853a26 # <<<< PREAMBLE CONTENT >>>> +from libc.stdint cimport ( + intptr_t, + uintptr_t, +) + cdef extern from * nogil: """ #if defined(_MSC_VER) && !defined(__clang__) @@ -44,11 +49,6 @@ cdef extern from "": ctypedef void* HMODULE void* _cyb_GetProcAddress "GetProcAddress"(HMODULE, const char*) nogil -from libc.stdint cimport ( - intptr_t, - uintptr_t, -) - import threading as _cyb_threading cdef int _cyb___py_nvfatbin_init = 0 diff --git a/cuda_bindings_13/cuda/bindings/_internal/nvjitlink_linux.pyx b/cuda_bindings_13/cuda/bindings/_internal/nvjitlink_linux.pyx index 4c21693caf7..ba20aa4b482 100644 --- a/cuda_bindings_13/cuda/bindings/_internal/nvjitlink_linux.pyx +++ b/cuda_bindings_13/cuda/bindings/_internal/nvjitlink_linux.pyx @@ -3,11 +3,16 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.0.1 to 13.4.1. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=a286ec6ed7fcdd0d82d6624d68c700cc3678e1e26f3ba1243df518cdeea5a992 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=dba1e396a2c0ab32045c04616c33ee9d515633a0ef0271726c7039783988d5e8 # <<<< PREAMBLE CONTENT >>>> +from libc.stdint cimport ( + intptr_t, + uint32_t, +) + cdef extern from * nogil: """ #if defined(_MSC_VER) && !defined(__clang__) @@ -44,11 +49,6 @@ cdef extern from "": void* _cyb_dlsym "dlsym"(void*, const char*) nogil const void * _cyb_RTLD_DEFAULT "RTLD_DEFAULT" -from libc.stdint cimport ( - intptr_t, - uint32_t, -) - import threading as _cyb_threading cdef int _cyb___py_nvjitlink_init = 0 diff --git a/cuda_bindings_13/cuda/bindings/_internal/nvjitlink_windows.pyx b/cuda_bindings_13/cuda/bindings/_internal/nvjitlink_windows.pyx index 9ce2fc111be..c35c6a91d13 100644 --- a/cuda_bindings_13/cuda/bindings/_internal/nvjitlink_windows.pyx +++ b/cuda_bindings_13/cuda/bindings/_internal/nvjitlink_windows.pyx @@ -3,11 +3,17 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.0.1 to 13.4.1. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=eef6c33c425f24828307c7fc62c45dcdd8b98e5dd47be467709f64eadfd432b2 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=e413ace365d4acd7019fb9dd78af2b46206fd4633cce4a5c905c39e1934911d5 # <<<< PREAMBLE CONTENT >>>> +from libc.stdint cimport ( + intptr_t, + uint32_t, + uintptr_t, +) + cdef extern from * nogil: """ #if defined(_MSC_VER) && !defined(__clang__) @@ -44,12 +50,6 @@ cdef extern from "": ctypedef void* HMODULE void* _cyb_GetProcAddress "GetProcAddress"(HMODULE, const char*) nogil -from libc.stdint cimport ( - intptr_t, - uint32_t, - uintptr_t, -) - import threading as _cyb_threading cdef int _cyb___py_nvjitlink_init = 0 diff --git a/cuda_bindings_13/cuda/bindings/_internal/nvml_linux.pyx b/cuda_bindings_13/cuda/bindings/_internal/nvml_linux.pyx index ab251a57fe1..fee348381f7 100644 --- a/cuda_bindings_13/cuda/bindings/_internal/nvml_linux.pyx +++ b/cuda_bindings_13/cuda/bindings/_internal/nvml_linux.pyx @@ -3,11 +3,13 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.1 to 13.4.1. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=77c516adfddaab32e14f7d0bf80b78c33d928198af0be5ea18ec7b880c9c09c9 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=d9fb0bf1d20a4742bc4fc5592772f41b04cdf47d403545f57cfbd6644724a7f4 # <<<< PREAMBLE CONTENT >>>> +from libc.stdint cimport intptr_t + cdef extern from * nogil: """ #if defined(_MSC_VER) && !defined(__clang__) @@ -44,8 +46,6 @@ cdef extern from "": void* _cyb_dlsym "dlsym"(void*, const char*) nogil const void * _cyb_RTLD_DEFAULT "RTLD_DEFAULT" -from libc.stdint cimport intptr_t - import threading as _cyb_threading cdef int _cyb___py_nvml_init = 0 diff --git a/cuda_bindings_13/cuda/bindings/_internal/nvml_windows.pyx b/cuda_bindings_13/cuda/bindings/_internal/nvml_windows.pyx index e5a7cf53a78..e0d834524b9 100644 --- a/cuda_bindings_13/cuda/bindings/_internal/nvml_windows.pyx +++ b/cuda_bindings_13/cuda/bindings/_internal/nvml_windows.pyx @@ -3,11 +3,16 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.1 to 13.4.1. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=5e4dabf79550bbf99149a55b67542f1b6bf20a48f3dbfd922848c16115418f5e +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=cc3fa2a97922f0213659b0616cb357c6530c01acadea396038c1158f28e78533 # <<<< PREAMBLE CONTENT >>>> +from libc.stdint cimport ( + intptr_t, + uintptr_t, +) + cdef extern from * nogil: """ #if defined(_MSC_VER) && !defined(__clang__) @@ -44,11 +49,6 @@ cdef extern from "": ctypedef void* HMODULE void* _cyb_GetProcAddress "GetProcAddress"(HMODULE, const char*) nogil -from libc.stdint cimport ( - intptr_t, - uintptr_t, -) - import threading as _cyb_threading cdef int _cyb___py_nvml_init = 0 diff --git a/cuda_bindings_13/cuda/bindings/_internal/nvrtc_linux.pyx b/cuda_bindings_13/cuda/bindings/_internal/nvrtc_linux.pyx index 861fc42e34b..136b056b608 100644 --- a/cuda_bindings_13/cuda/bindings/_internal/nvrtc_linux.pyx +++ b/cuda_bindings_13/cuda/bindings/_internal/nvrtc_linux.pyx @@ -3,11 +3,13 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.0 to 13.4.1. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=d8397f8100cfd6d26ff1c1f4ea795dd81e92f4beb60d304b5306733152305760 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=7e4f779cb95262a9ce50e2c887489437d1a16d883f4f45476378655bb5e1fc69 # <<<< PREAMBLE CONTENT >>>> +from libc.stdint cimport intptr_t + cdef extern from * nogil: """ #if defined(_MSC_VER) && !defined(__clang__) @@ -44,8 +46,6 @@ cdef extern from "": void* _cyb_dlsym "dlsym"(void*, const char*) nogil const void * _cyb_RTLD_DEFAULT "RTLD_DEFAULT" -from libc.stdint cimport intptr_t - import threading as _cyb_threading cdef int _cyb___py_nvrtc_init = 0 diff --git a/cuda_bindings_13/cuda/bindings/_internal/nvrtc_windows.pyx b/cuda_bindings_13/cuda/bindings/_internal/nvrtc_windows.pyx index 917f6c45dd6..482a4de3f2d 100644 --- a/cuda_bindings_13/cuda/bindings/_internal/nvrtc_windows.pyx +++ b/cuda_bindings_13/cuda/bindings/_internal/nvrtc_windows.pyx @@ -3,11 +3,16 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.0 to 13.4.1. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=b324edc3b551146f59d4df5588a6f5d1f06ec91d193333dcda5c35ca49dc251d +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=b9e4b87d212e5799014bbf50cb40078826014cfcc73ff22c6c74deeb39a5a905 # <<<< PREAMBLE CONTENT >>>> +from libc.stdint cimport ( + intptr_t, + uintptr_t, +) + cdef extern from * nogil: """ #if defined(_MSC_VER) && !defined(__clang__) @@ -44,11 +49,6 @@ cdef extern from "": ctypedef void* HMODULE void* _cyb_GetProcAddress "GetProcAddress"(HMODULE, const char*) nogil -from libc.stdint cimport ( - intptr_t, - uintptr_t, -) - import threading as _cyb_threading cdef int _cyb___py_nvrtc_init = 0 diff --git a/cuda_bindings_13/cuda/bindings/_internal/nvvm_linux.pyx b/cuda_bindings_13/cuda/bindings/_internal/nvvm_linux.pyx index 39329bc9b64..9d87f31b892 100644 --- a/cuda_bindings_13/cuda/bindings/_internal/nvvm_linux.pyx +++ b/cuda_bindings_13/cuda/bindings/_internal/nvvm_linux.pyx @@ -3,11 +3,13 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.0.1 to 13.4.1. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=cf645e79d2d72cd4c10d5f4fcd6bab245f292559ac432180554c0d944aa03dae +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=dd3979ce7ab7c6374aa8a0ed49624576a4ede9f29a9e05f8c70bd9422ae797f3 # <<<< PREAMBLE CONTENT >>>> +from libc.stdint cimport intptr_t + cdef extern from * nogil: """ #if defined(_MSC_VER) && !defined(__clang__) @@ -44,8 +46,6 @@ cdef extern from "": void* _cyb_dlsym "dlsym"(void*, const char*) nogil const void * _cyb_RTLD_DEFAULT "RTLD_DEFAULT" -from libc.stdint cimport intptr_t - import threading as _cyb_threading cdef int _cyb___py_nvvm_init = 0 diff --git a/cuda_bindings_13/cuda/bindings/_internal/nvvm_windows.pyx b/cuda_bindings_13/cuda/bindings/_internal/nvvm_windows.pyx index 047c99f2b9f..c33126df053 100644 --- a/cuda_bindings_13/cuda/bindings/_internal/nvvm_windows.pyx +++ b/cuda_bindings_13/cuda/bindings/_internal/nvvm_windows.pyx @@ -3,11 +3,16 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.0.1 to 13.4.1. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=d826369ce197164240eae2ca22bc88bb193a3ec936946b9d3b5b906b503fb446 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=640a4399ee31052cd30898b0e6e73d424683a67376594d4e6d92c80918cdcdaa # <<<< PREAMBLE CONTENT >>>> +from libc.stdint cimport ( + intptr_t, + uintptr_t, +) + cdef extern from * nogil: """ #if defined(_MSC_VER) && !defined(__clang__) @@ -44,11 +49,6 @@ cdef extern from "": ctypedef void* HMODULE void* _cyb_GetProcAddress "GetProcAddress"(HMODULE, const char*) nogil -from libc.stdint cimport ( - intptr_t, - uintptr_t, -) - import threading as _cyb_threading cdef int _cyb___py_nvvm_init = 0 diff --git a/cuda_bindings_13/cuda/bindings/_v2/driver.pyx b/cuda_bindings_13/cuda/bindings/_v2/driver.pyx index b469cb8a519..65f0f99a6b2 100644 --- a/cuda_bindings_13/cuda/bindings/_v2/driver.pyx +++ b/cuda_bindings_13/cuda/bindings/_v2/driver.pyx @@ -3,7 +3,7 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.0 to 13.4.1. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=cc1ac70b43586bcc18fa53eaf2741642b15689e14a6882e41062b817f36e80ab +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=2aeb6615dc0c6ffb24ee43dc713535be3e3dca8dcf13c42bdc7d3a1cf3326c11 # <<<< PREAMBLE CONTENT >>>> @@ -58,6 +58,14 @@ cdef _cyb___getbuffer(object self, _cyb_cpython.Py_buffer *buffer, void *ptr, in buffer.strides = &buffer.itemsize buffer.suboffsets = NULL +cdef inline intptr_t _cyb_array_ptr(object arr) except? 0: + cdef _cyb_cpython.Py_buffer view + cdef intptr_t ptr + _cyb_cpython.PyObject_GetBuffer(arr, &view, _cyb_cpython_buffer.PyBUF_STRIDES) + ptr = view.buf + _cyb_cpython.PyBuffer_Release(&view) + return ptr + cdef _cyb_from_buffer(buffer, size, lowpp_type): cdef _cyb_cpython.Py_buffer view if _cyb_cpython.PyObject_GetBuffer(buffer, &view, _cyb_cpython_buffer.PyBUF_SIMPLE) != 0: @@ -5554,6 +5562,7 @@ cdef _get_graph_edge_data_dtype_offsets(): }) graph_edge_data_dtype = _get_graph_edge_data_dtype_offsets() +cdef object graph_edge_data_dtype_record = _numpy.dtype((_numpy.record, graph_edge_data_dtype)) cdef class GraphEdgeData: """Empty-initialize an array of `CUgraphEdgeData`. @@ -5570,8 +5579,7 @@ cdef class GraphEdgeData: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=graph_edge_data_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=graph_edge_data_dtype_record) assert self._data.itemsize == sizeof(CUgraphEdgeData), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(CUgraphEdgeData) }" @@ -5584,17 +5592,17 @@ cdef class GraphEdgeData: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -5615,44 +5623,45 @@ cdef class GraphEdgeData: def from_port(self): """Union[~_numpy.uint8, int]: """ if self._data.size == 1: - return int(self._data.from_port[0]) - return self._data.from_port + return int(self._data["from_port"][0]) + return self._data["from_port"] @from_port.setter def from_port(self, val): if not self._data.flags.writeable: raise ValueError("This GraphEdgeData instance is read-only") - self._data.from_port = val + self._data["from_port"] = val @property def to_port(self): """Union[~_numpy.uint8, int]: """ if self._data.size == 1: - return int(self._data.to_port[0]) - return self._data.to_port + return int(self._data["to_port"][0]) + return self._data["to_port"] @to_port.setter def to_port(self, val): if not self._data.flags.writeable: raise ValueError("This GraphEdgeData instance is read-only") - self._data.to_port = val + self._data["to_port"] = val @property def type(self): """Union[~_numpy.uint8, int]: """ if self._data.size == 1: - return int(self._data.type[0]) - return self._data.type + return int(self._data["type"][0]) + return self._data["type"] @type.setter def type(self, val): if not self._data.flags.writeable: raise ValueError("This GraphEdgeData instance is read-only") - self._data.type = val + self._data["type"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef GraphEdgeData obj if isinstance(key, int): key_ = key size = self._data.size @@ -5660,10 +5669,18 @@ cdef class GraphEdgeData: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return GraphEdgeData.from_data(self._data[key_:key_+1]) + obj = GraphEdgeData.__new__(GraphEdgeData) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == graph_edge_data_dtype: - return GraphEdgeData.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == graph_edge_data_dtype: + obj = GraphEdgeData.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -5688,8 +5705,7 @@ cdef class GraphEdgeData: raise ValueError("data array must be 1D") if data.dtype != graph_edge_data_dtype: raise ValueError("data array must be of dtype graph_edge_data_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=graph_edge_data_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -5709,10 +5725,8 @@ cdef class GraphEdgeData: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(CUgraphEdgeData) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=graph_edge_data_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=graph_edge_data_dtype_record) obj._owner = owner - return obj @@ -15023,6 +15037,7 @@ cdef _get_dev_sm_resource_group_params_dtype_offsets(): }) dev_sm_resource_group_params_dtype = _get_dev_sm_resource_group_params_dtype_offsets() +cdef object dev_sm_resource_group_params_dtype_record = _numpy.dtype((_numpy.record, dev_sm_resource_group_params_dtype)) cdef class DevSmResourceGroupParams: """Empty-initialize an array of `CU_DEV_SM_RESOURCE_GROUP_PARAMS`. @@ -15039,8 +15054,7 @@ cdef class DevSmResourceGroupParams: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=dev_sm_resource_group_params_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=dev_sm_resource_group_params_dtype_record) assert self._data.itemsize == sizeof(CU_DEV_SM_RESOURCE_GROUP_PARAMS), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(CU_DEV_SM_RESOURCE_GROUP_PARAMS) }" @@ -15053,17 +15067,17 @@ cdef class DevSmResourceGroupParams: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -15084,70 +15098,71 @@ cdef class DevSmResourceGroupParams: def sm_count(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.sm_count[0]) - return self._data.sm_count + return int(self._data["sm_count"][0]) + return self._data["sm_count"] @sm_count.setter def sm_count(self, val): if not self._data.flags.writeable: raise ValueError("This DevSmResourceGroupParams instance is read-only") - self._data.sm_count = val + self._data["sm_count"] = val @property def coscheduled_sm_count(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.coscheduled_sm_count[0]) - return self._data.coscheduled_sm_count + return int(self._data["coscheduled_sm_count"][0]) + return self._data["coscheduled_sm_count"] @coscheduled_sm_count.setter def coscheduled_sm_count(self, val): if not self._data.flags.writeable: raise ValueError("This DevSmResourceGroupParams instance is read-only") - self._data.coscheduled_sm_count = val + self._data["coscheduled_sm_count"] = val @property def preferred_coscheduled_sm_count(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.preferred_coscheduled_sm_count[0]) - return self._data.preferred_coscheduled_sm_count + return int(self._data["preferred_coscheduled_sm_count"][0]) + return self._data["preferred_coscheduled_sm_count"] @preferred_coscheduled_sm_count.setter def preferred_coscheduled_sm_count(self, val): if not self._data.flags.writeable: raise ValueError("This DevSmResourceGroupParams instance is read-only") - self._data.preferred_coscheduled_sm_count = val + self._data["preferred_coscheduled_sm_count"] = val @property def flags_(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.flags_[0]) - return self._data.flags_ + return int(self._data["flags_"][0]) + return self._data["flags_"] @flags_.setter def flags_(self, val): if not self._data.flags.writeable: raise ValueError("This DevSmResourceGroupParams instance is read-only") - self._data.flags_ = val + self._data["flags_"] = val @property def locality_domain_id(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.locality_domain_id[0]) - return self._data.locality_domain_id + return int(self._data["locality_domain_id"][0]) + return self._data["locality_domain_id"] @locality_domain_id.setter def locality_domain_id(self, val): if not self._data.flags.writeable: raise ValueError("This DevSmResourceGroupParams instance is read-only") - self._data.locality_domain_id = val + self._data["locality_domain_id"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef DevSmResourceGroupParams obj if isinstance(key, int): key_ = key size = self._data.size @@ -15155,10 +15170,18 @@ cdef class DevSmResourceGroupParams: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return DevSmResourceGroupParams.from_data(self._data[key_:key_+1]) + obj = DevSmResourceGroupParams.__new__(DevSmResourceGroupParams) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == dev_sm_resource_group_params_dtype: - return DevSmResourceGroupParams.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == dev_sm_resource_group_params_dtype: + obj = DevSmResourceGroupParams.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -15183,8 +15206,7 @@ cdef class DevSmResourceGroupParams: raise ValueError("data array must be 1D") if data.dtype != dev_sm_resource_group_params_dtype: raise ValueError("data array must be of dtype dev_sm_resource_group_params_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=dev_sm_resource_group_params_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -15204,10 +15226,8 @@ cdef class DevSmResourceGroupParams: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(CU_DEV_SM_RESOURCE_GROUP_PARAMS) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=dev_sm_resource_group_params_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=dev_sm_resource_group_params_dtype_record) obj._owner = owner - return obj @@ -15766,6 +15786,7 @@ cdef _get_clique_info_dtype_offsets(): }) clique_info_dtype = _get_clique_info_dtype_offsets() +cdef object clique_info_dtype_record = _numpy.dtype((_numpy.record, clique_info_dtype)) cdef class CliqueInfo: """Empty-initialize an array of `CUcliqueInfo`. @@ -15782,8 +15803,7 @@ cdef class CliqueInfo: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=clique_info_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=clique_info_dtype_record) assert self._data.itemsize == sizeof(CUcliqueInfo), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(CUcliqueInfo) }" @@ -15796,17 +15816,17 @@ cdef class CliqueInfo: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -15827,31 +15847,32 @@ cdef class CliqueInfo: def type(self): """Union[~_numpy.int32, int]: """ if self._data.size == 1: - return int(self._data.type[0]) - return self._data.type + return int(self._data["type"][0]) + return self._data["type"] @type.setter def type(self, val): if not self._data.flags.writeable: raise ValueError("This CliqueInfo instance is read-only") - self._data.type = val + self._data["type"] = val @property def id(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.id[0]) - return self._data.id + return int(self._data["id"][0]) + return self._data["id"] @id.setter def id(self, val): if not self._data.flags.writeable: raise ValueError("This CliqueInfo instance is read-only") - self._data.id = val + self._data["id"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef CliqueInfo obj if isinstance(key, int): key_ = key size = self._data.size @@ -15859,10 +15880,18 @@ cdef class CliqueInfo: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return CliqueInfo.from_data(self._data[key_:key_+1]) + obj = CliqueInfo.__new__(CliqueInfo) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == clique_info_dtype: - return CliqueInfo.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == clique_info_dtype: + obj = CliqueInfo.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -15887,8 +15916,7 @@ cdef class CliqueInfo: raise ValueError("data array must be 1D") if data.dtype != clique_info_dtype: raise ValueError("data array must be of dtype clique_info_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=clique_info_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -15908,10 +15936,8 @@ cdef class CliqueInfo: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(CUcliqueInfo) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=clique_info_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=clique_info_dtype_record) obj._owner = owner - return obj @@ -19276,6 +19302,7 @@ cdef _get_stream_batch_mem_op_params_v1_dtype_offsets(): }) stream_batch_mem_op_params_v1_dtype = _get_stream_batch_mem_op_params_v1_dtype_offsets() +cdef object stream_batch_mem_op_params_v1_dtype_record = _numpy.dtype((_numpy.record, stream_batch_mem_op_params_v1_dtype)) cdef class StreamBatchMemOpParams_v1: """Empty-initialize an array of `CUstreamBatchMemOpParams_v1`. @@ -19297,41 +19324,9 @@ cdef class StreamBatchMemOpParams_v1: readonly tuple _atomic_reduction def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=stream_batch_mem_op_params_v1_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=stream_batch_mem_op_params_v1_dtype_record) assert self._data.itemsize == sizeof(CUstreamBatchMemOpParams_v1), \ f"itemsize {self._data.itemsize} mismatches union size { sizeof(CUstreamBatchMemOpParams_v1) }" - obj = self - wait_value_list = list() - for i in range(obj._data.size): - addr = obj._data.wait_value[i].__array_interface__['data'][0] - wait_value_obj = StreamMemOpWaitValueParams.from_ptr(addr, owner=obj, readonly=False) - wait_value_list.append(wait_value_obj) - obj._wait_value = tuple(wait_value_list) - write_value_list = list() - for i in range(obj._data.size): - addr = obj._data.write_value[i].__array_interface__['data'][0] - write_value_obj = StreamMemOpWriteValueParams.from_ptr(addr, owner=obj, readonly=False) - write_value_list.append(write_value_obj) - obj._write_value = tuple(write_value_list) - flush_remote_writes_list = list() - for i in range(obj._data.size): - addr = obj._data.flush_remote_writes[i].__array_interface__['data'][0] - flush_remote_writes_obj = StreamMemOpFlushRemoteWritesParams.from_ptr(addr, owner=obj, readonly=False) - flush_remote_writes_list.append(flush_remote_writes_obj) - obj._flush_remote_writes = tuple(flush_remote_writes_list) - memory_barrier_list = list() - for i in range(obj._data.size): - addr = obj._data.memory_barrier[i].__array_interface__['data'][0] - memory_barrier_obj = StreamMemOpMemoryBarrierParams.from_ptr(addr, owner=obj, readonly=False) - memory_barrier_list.append(memory_barrier_obj) - obj._memory_barrier = tuple(memory_barrier_list) - atomic_reduction_list = list() - for i in range(obj._data.size): - addr = obj._data.atomic_reduction[i].__array_interface__['data'][0] - atomic_reduction_obj = StreamMemOpAtomicReductionParams.from_ptr(addr, owner=obj, readonly=False) - atomic_reduction_list.append(atomic_reduction_obj) - obj._atomic_reduction = tuple(atomic_reduction_list) def __repr__(self): if self._data.size > 1: @@ -19342,17 +19337,17 @@ cdef class StreamBatchMemOpParams_v1: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -19372,6 +19367,17 @@ cdef class StreamBatchMemOpParams_v1: @property def wait_value(self): """StreamMemOpWaitValueParams: """ + if self._wait_value is None: + wait_value_list = list() + wait_value_base = _cyb_array_ptr(self._data) + wait_value_offset = stream_batch_mem_op_params_v1_dtype.fields["wait_value"][1] + wait_value_stride = self._data.strides[0] + wait_value_readonly = not self._data.flags.writeable + for i in range(self._data.size): + addr = wait_value_base + i * wait_value_stride + wait_value_offset + wait_value_obj = StreamMemOpWaitValueParams.from_ptr(addr, owner=self, readonly=wait_value_readonly) + wait_value_list.append(wait_value_obj) + self._wait_value = tuple(wait_value_list) if self._data.size == 1: return self._wait_value[0] return self._wait_value @@ -19383,12 +19389,23 @@ cdef class StreamBatchMemOpParams_v1: cdef StreamMemOpWaitValueParams val_ = val if self._data.size != 1: raise ValueError("Assign to the member of one element, e.g. array[i].wait_value = value") - cdef intptr_t addr = self._data.wait_value[0].__array_interface__['data'][0] + cdef intptr_t addr = _cyb_array_ptr(self._data) + stream_batch_mem_op_params_v1_dtype.fields["wait_value"][1] _cyb_memcpy(addr, (val_._get_ptr()), sizeof(CUstreamMemOpWaitValueParams_st) * 1) @property def write_value(self): """StreamMemOpWriteValueParams: """ + if self._write_value is None: + write_value_list = list() + write_value_base = _cyb_array_ptr(self._data) + write_value_offset = stream_batch_mem_op_params_v1_dtype.fields["write_value"][1] + write_value_stride = self._data.strides[0] + write_value_readonly = not self._data.flags.writeable + for i in range(self._data.size): + addr = write_value_base + i * write_value_stride + write_value_offset + write_value_obj = StreamMemOpWriteValueParams.from_ptr(addr, owner=self, readonly=write_value_readonly) + write_value_list.append(write_value_obj) + self._write_value = tuple(write_value_list) if self._data.size == 1: return self._write_value[0] return self._write_value @@ -19400,12 +19417,23 @@ cdef class StreamBatchMemOpParams_v1: cdef StreamMemOpWriteValueParams val_ = val if self._data.size != 1: raise ValueError("Assign to the member of one element, e.g. array[i].write_value = value") - cdef intptr_t addr = self._data.write_value[0].__array_interface__['data'][0] + cdef intptr_t addr = _cyb_array_ptr(self._data) + stream_batch_mem_op_params_v1_dtype.fields["write_value"][1] _cyb_memcpy(addr, (val_._get_ptr()), sizeof(CUstreamMemOpWriteValueParams_st) * 1) @property def flush_remote_writes(self): """StreamMemOpFlushRemoteWritesParams: """ + if self._flush_remote_writes is None: + flush_remote_writes_list = list() + flush_remote_writes_base = _cyb_array_ptr(self._data) + flush_remote_writes_offset = stream_batch_mem_op_params_v1_dtype.fields["flush_remote_writes"][1] + flush_remote_writes_stride = self._data.strides[0] + flush_remote_writes_readonly = not self._data.flags.writeable + for i in range(self._data.size): + addr = flush_remote_writes_base + i * flush_remote_writes_stride + flush_remote_writes_offset + flush_remote_writes_obj = StreamMemOpFlushRemoteWritesParams.from_ptr(addr, owner=self, readonly=flush_remote_writes_readonly) + flush_remote_writes_list.append(flush_remote_writes_obj) + self._flush_remote_writes = tuple(flush_remote_writes_list) if self._data.size == 1: return self._flush_remote_writes[0] return self._flush_remote_writes @@ -19417,12 +19445,23 @@ cdef class StreamBatchMemOpParams_v1: cdef StreamMemOpFlushRemoteWritesParams val_ = val if self._data.size != 1: raise ValueError("Assign to the member of one element, e.g. array[i].flush_remote_writes = value") - cdef intptr_t addr = self._data.flush_remote_writes[0].__array_interface__['data'][0] + cdef intptr_t addr = _cyb_array_ptr(self._data) + stream_batch_mem_op_params_v1_dtype.fields["flush_remote_writes"][1] _cyb_memcpy(addr, (val_._get_ptr()), sizeof(CUstreamMemOpFlushRemoteWritesParams_st) * 1) @property def memory_barrier(self): """StreamMemOpMemoryBarrierParams: """ + if self._memory_barrier is None: + memory_barrier_list = list() + memory_barrier_base = _cyb_array_ptr(self._data) + memory_barrier_offset = stream_batch_mem_op_params_v1_dtype.fields["memory_barrier"][1] + memory_barrier_stride = self._data.strides[0] + memory_barrier_readonly = not self._data.flags.writeable + for i in range(self._data.size): + addr = memory_barrier_base + i * memory_barrier_stride + memory_barrier_offset + memory_barrier_obj = StreamMemOpMemoryBarrierParams.from_ptr(addr, owner=self, readonly=memory_barrier_readonly) + memory_barrier_list.append(memory_barrier_obj) + self._memory_barrier = tuple(memory_barrier_list) if self._data.size == 1: return self._memory_barrier[0] return self._memory_barrier @@ -19434,12 +19473,23 @@ cdef class StreamBatchMemOpParams_v1: cdef StreamMemOpMemoryBarrierParams val_ = val if self._data.size != 1: raise ValueError("Assign to the member of one element, e.g. array[i].memory_barrier = value") - cdef intptr_t addr = self._data.memory_barrier[0].__array_interface__['data'][0] + cdef intptr_t addr = _cyb_array_ptr(self._data) + stream_batch_mem_op_params_v1_dtype.fields["memory_barrier"][1] _cyb_memcpy(addr, (val_._get_ptr()), sizeof(CUstreamMemOpMemoryBarrierParams_st) * 1) @property def atomic_reduction(self): """StreamMemOpAtomicReductionParams: """ + if self._atomic_reduction is None: + atomic_reduction_list = list() + atomic_reduction_base = _cyb_array_ptr(self._data) + atomic_reduction_offset = stream_batch_mem_op_params_v1_dtype.fields["atomic_reduction"][1] + atomic_reduction_stride = self._data.strides[0] + atomic_reduction_readonly = not self._data.flags.writeable + for i in range(self._data.size): + addr = atomic_reduction_base + i * atomic_reduction_stride + atomic_reduction_offset + atomic_reduction_obj = StreamMemOpAtomicReductionParams.from_ptr(addr, owner=self, readonly=atomic_reduction_readonly) + atomic_reduction_list.append(atomic_reduction_obj) + self._atomic_reduction = tuple(atomic_reduction_list) if self._data.size == 1: return self._atomic_reduction[0] return self._atomic_reduction @@ -19451,25 +19501,26 @@ cdef class StreamBatchMemOpParams_v1: cdef StreamMemOpAtomicReductionParams val_ = val if self._data.size != 1: raise ValueError("Assign to the member of one element, e.g. array[i].atomic_reduction = value") - cdef intptr_t addr = self._data.atomic_reduction[0].__array_interface__['data'][0] + cdef intptr_t addr = _cyb_array_ptr(self._data) + stream_batch_mem_op_params_v1_dtype.fields["atomic_reduction"][1] _cyb_memcpy(addr, (val_._get_ptr()), sizeof(CUstreamMemOpAtomicReductionParams_st) * 1) @property def operation(self): """Union[~_numpy.int32, int]: """ if self._data.size == 1: - return int(self._data.operation[0]) - return self._data.operation + return int(self._data["operation"][0]) + return self._data["operation"] @operation.setter def operation(self, val): if not self._data.flags.writeable: raise ValueError("This StreamBatchMemOpParams_v1 instance is read-only") - self._data.operation = val + self._data["operation"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef StreamBatchMemOpParams_v1 obj if isinstance(key, int): key_ = key size = self._data.size @@ -19477,10 +19528,18 @@ cdef class StreamBatchMemOpParams_v1: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return StreamBatchMemOpParams_v1.from_data(self._data[key_:key_+1]) + obj = StreamBatchMemOpParams_v1.__new__(StreamBatchMemOpParams_v1) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == stream_batch_mem_op_params_v1_dtype: - return StreamBatchMemOpParams_v1.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == stream_batch_mem_op_params_v1_dtype: + obj = StreamBatchMemOpParams_v1.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -19505,38 +19564,7 @@ cdef class StreamBatchMemOpParams_v1: raise ValueError("data array must be 1D") if data.dtype != stream_batch_mem_op_params_v1_dtype: raise ValueError("data array must be of dtype stream_batch_mem_op_params_v1_dtype") - obj._data = data.view(_numpy.recarray) - - wait_value_list = list() - for i in range(obj._data.size): - addr = obj._data.wait_value[i].__array_interface__['data'][0] - wait_value_obj = StreamMemOpWaitValueParams.from_ptr(addr, owner=obj, readonly=False) - wait_value_list.append(wait_value_obj) - obj._wait_value = tuple(wait_value_list) - write_value_list = list() - for i in range(obj._data.size): - addr = obj._data.write_value[i].__array_interface__['data'][0] - write_value_obj = StreamMemOpWriteValueParams.from_ptr(addr, owner=obj, readonly=False) - write_value_list.append(write_value_obj) - obj._write_value = tuple(write_value_list) - flush_remote_writes_list = list() - for i in range(obj._data.size): - addr = obj._data.flush_remote_writes[i].__array_interface__['data'][0] - flush_remote_writes_obj = StreamMemOpFlushRemoteWritesParams.from_ptr(addr, owner=obj, readonly=False) - flush_remote_writes_list.append(flush_remote_writes_obj) - obj._flush_remote_writes = tuple(flush_remote_writes_list) - memory_barrier_list = list() - for i in range(obj._data.size): - addr = obj._data.memory_barrier[i].__array_interface__['data'][0] - memory_barrier_obj = StreamMemOpMemoryBarrierParams.from_ptr(addr, owner=obj, readonly=False) - memory_barrier_list.append(memory_barrier_obj) - obj._memory_barrier = tuple(memory_barrier_list) - atomic_reduction_list = list() - for i in range(obj._data.size): - addr = obj._data.atomic_reduction[i].__array_interface__['data'][0] - atomic_reduction_obj = StreamMemOpAtomicReductionParams.from_ptr(addr, owner=obj, readonly=False) - atomic_reduction_list.append(atomic_reduction_obj) - obj._atomic_reduction = tuple(atomic_reduction_list) + obj._data = data.view(dtype=stream_batch_mem_op_params_v1_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -19556,40 +19584,8 @@ cdef class StreamBatchMemOpParams_v1: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(CUstreamBatchMemOpParams_v1) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=stream_batch_mem_op_params_v1_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=stream_batch_mem_op_params_v1_dtype_record) obj._owner = owner - - wait_value_list = list() - for i in range(obj._data.size): - addr = obj._data.wait_value[i].__array_interface__['data'][0] - wait_value_obj = StreamMemOpWaitValueParams.from_ptr(addr, owner=obj, readonly=readonly) - wait_value_list.append(wait_value_obj) - obj._wait_value = tuple(wait_value_list) - write_value_list = list() - for i in range(obj._data.size): - addr = obj._data.write_value[i].__array_interface__['data'][0] - write_value_obj = StreamMemOpWriteValueParams.from_ptr(addr, owner=obj, readonly=readonly) - write_value_list.append(write_value_obj) - obj._write_value = tuple(write_value_list) - flush_remote_writes_list = list() - for i in range(obj._data.size): - addr = obj._data.flush_remote_writes[i].__array_interface__['data'][0] - flush_remote_writes_obj = StreamMemOpFlushRemoteWritesParams.from_ptr(addr, owner=obj, readonly=readonly) - flush_remote_writes_list.append(flush_remote_writes_obj) - obj._flush_remote_writes = tuple(flush_remote_writes_list) - memory_barrier_list = list() - for i in range(obj._data.size): - addr = obj._data.memory_barrier[i].__array_interface__['data'][0] - memory_barrier_obj = StreamMemOpMemoryBarrierParams.from_ptr(addr, owner=obj, readonly=readonly) - memory_barrier_list.append(memory_barrier_obj) - obj._memory_barrier = tuple(memory_barrier_list) - atomic_reduction_list = list() - for i in range(obj._data.size): - addr = obj._data.atomic_reduction[i].__array_interface__['data'][0] - atomic_reduction_obj = StreamMemOpAtomicReductionParams.from_ptr(addr, owner=obj, readonly=readonly) - atomic_reduction_list.append(atomic_reduction_obj) - obj._atomic_reduction = tuple(atomic_reduction_list) return obj @@ -19890,6 +19886,7 @@ cdef _get_exec_affinity_param_v1_dtype_offsets(): }) exec_affinity_param_v1_dtype = _get_exec_affinity_param_v1_dtype_offsets() +cdef object exec_affinity_param_v1_dtype_record = _numpy.dtype((_numpy.record, exec_affinity_param_v1_dtype)) cdef class ExecAffinityParam_v1: """Empty-initialize an array of `CUexecAffinityParam_v1`. @@ -19907,17 +19904,9 @@ cdef class ExecAffinityParam_v1: readonly tuple _param def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=exec_affinity_param_v1_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=exec_affinity_param_v1_dtype_record) assert self._data.itemsize == sizeof(CUexecAffinityParam_v1), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(CUexecAffinityParam_v1) }" - obj = self - param_list = list() - for i in range(obj._data.size): - addr = obj._data.param[i].__array_interface__['data'][0] - param_obj = _py_anon_pod10.from_ptr(addr, owner=obj, readonly=False) - param_list.append(param_obj) - obj._param = tuple(param_list) def __repr__(self): if self._data.size > 1: @@ -19928,17 +19917,17 @@ cdef class ExecAffinityParam_v1: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -19958,6 +19947,17 @@ cdef class ExecAffinityParam_v1: @property def param(self): """_py_anon_pod10: """ + if self._param is None: + param_list = list() + param_base = _cyb_array_ptr(self._data) + param_offset = exec_affinity_param_v1_dtype.fields["param"][1] + param_stride = self._data.strides[0] + param_readonly = not self._data.flags.writeable + for i in range(self._data.size): + addr = param_base + i * param_stride + param_offset + param_obj = _py_anon_pod10.from_ptr(addr, owner=self, readonly=param_readonly) + param_list.append(param_obj) + self._param = tuple(param_list) if self._data.size == 1: return self._param[0] return self._param @@ -19969,25 +19969,26 @@ cdef class ExecAffinityParam_v1: cdef _py_anon_pod10 val_ = val if self._data.size != 1: raise ValueError("Assign to the member of one element, e.g. array[i].param = value") - cdef intptr_t addr = self._data.param[0].__array_interface__['data'][0] + cdef intptr_t addr = _cyb_array_ptr(self._data) + exec_affinity_param_v1_dtype.fields["param"][1] _cyb_memcpy(addr, (val_._get_ptr()), sizeof(cuda_bindings_driver__anon_pod10) * 1) @property def type(self): """Union[~_numpy.int32, int]: """ if self._data.size == 1: - return int(self._data.type[0]) - return self._data.type + return int(self._data["type"][0]) + return self._data["type"] @type.setter def type(self, val): if not self._data.flags.writeable: raise ValueError("This ExecAffinityParam_v1 instance is read-only") - self._data.type = val + self._data["type"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef ExecAffinityParam_v1 obj if isinstance(key, int): key_ = key size = self._data.size @@ -19995,10 +19996,18 @@ cdef class ExecAffinityParam_v1: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return ExecAffinityParam_v1.from_data(self._data[key_:key_+1]) + obj = ExecAffinityParam_v1.__new__(ExecAffinityParam_v1) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == exec_affinity_param_v1_dtype: - return ExecAffinityParam_v1.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == exec_affinity_param_v1_dtype: + obj = ExecAffinityParam_v1.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -20023,14 +20032,7 @@ cdef class ExecAffinityParam_v1: raise ValueError("data array must be 1D") if data.dtype != exec_affinity_param_v1_dtype: raise ValueError("data array must be of dtype exec_affinity_param_v1_dtype") - obj._data = data.view(_numpy.recarray) - - param_list = list() - for i in range(obj._data.size): - addr = obj._data.param[i].__array_interface__['data'][0] - param_obj = _py_anon_pod10.from_ptr(addr, owner=obj, readonly=False) - param_list.append(param_obj) - obj._param = tuple(param_list) + obj._data = data.view(dtype=exec_affinity_param_v1_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -20050,16 +20052,8 @@ cdef class ExecAffinityParam_v1: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(CUexecAffinityParam_v1) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=exec_affinity_param_v1_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=exec_affinity_param_v1_dtype_record) obj._owner = owner - - param_list = list() - for i in range(obj._data.size): - addr = obj._data.param[i].__array_interface__['data'][0] - param_obj = _py_anon_pod10.from_ptr(addr, owner=obj, readonly=readonly) - param_list.append(param_obj) - obj._param = tuple(param_list) return obj @@ -20847,6 +20841,7 @@ cdef _get_array_map_info_v1_dtype_offsets(): }) array_map_info_v1_dtype = _get_array_map_info_v1_dtype_offsets() +cdef object array_map_info_v1_dtype_record = _numpy.dtype((_numpy.record, array_map_info_v1_dtype)) cdef class ArrayMapInfo_v1: """Empty-initialize an array of `CUarrayMapInfo_v1`. @@ -20866,29 +20861,9 @@ cdef class ArrayMapInfo_v1: readonly tuple _mem_handle def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=array_map_info_v1_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=array_map_info_v1_dtype_record) assert self._data.itemsize == sizeof(CUarrayMapInfo_v1), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(CUarrayMapInfo_v1) }" - obj = self - resource_list = list() - for i in range(obj._data.size): - addr = obj._data.resource[i].__array_interface__['data'][0] - resource_obj = _py_anon_pod32.from_ptr(addr, owner=obj, readonly=False) - resource_list.append(resource_obj) - obj._resource = tuple(resource_list) - subresource_list = list() - for i in range(obj._data.size): - addr = obj._data.subresource[i].__array_interface__['data'][0] - subresource_obj = _py_anon_pod33.from_ptr(addr, owner=obj, readonly=False) - subresource_list.append(subresource_obj) - obj._subresource = tuple(subresource_list) - mem_handle_list = list() - for i in range(obj._data.size): - addr = obj._data.mem_handle[i].__array_interface__['data'][0] - mem_handle_obj = _py_anon_pod36.from_ptr(addr, owner=obj, readonly=False) - mem_handle_list.append(mem_handle_obj) - obj._mem_handle = tuple(mem_handle_list) def __repr__(self): if self._data.size > 1: @@ -20899,17 +20874,17 @@ cdef class ArrayMapInfo_v1: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -20929,6 +20904,17 @@ cdef class ArrayMapInfo_v1: @property def resource(self): """_py_anon_pod32: """ + if self._resource is None: + resource_list = list() + resource_base = _cyb_array_ptr(self._data) + resource_offset = array_map_info_v1_dtype.fields["resource"][1] + resource_stride = self._data.strides[0] + resource_readonly = not self._data.flags.writeable + for i in range(self._data.size): + addr = resource_base + i * resource_stride + resource_offset + resource_obj = _py_anon_pod32.from_ptr(addr, owner=self, readonly=resource_readonly) + resource_list.append(resource_obj) + self._resource = tuple(resource_list) if self._data.size == 1: return self._resource[0] return self._resource @@ -20940,12 +20926,23 @@ cdef class ArrayMapInfo_v1: cdef _py_anon_pod32 val_ = val if self._data.size != 1: raise ValueError("Assign to the member of one element, e.g. array[i].resource = value") - cdef intptr_t addr = self._data.resource[0].__array_interface__['data'][0] + cdef intptr_t addr = _cyb_array_ptr(self._data) + array_map_info_v1_dtype.fields["resource"][1] _cyb_memcpy(addr, (val_._get_ptr()), sizeof(cuda_bindings_driver__anon_pod32) * 1) @property def subresource(self): """_py_anon_pod33: """ + if self._subresource is None: + subresource_list = list() + subresource_base = _cyb_array_ptr(self._data) + subresource_offset = array_map_info_v1_dtype.fields["subresource"][1] + subresource_stride = self._data.strides[0] + subresource_readonly = not self._data.flags.writeable + for i in range(self._data.size): + addr = subresource_base + i * subresource_stride + subresource_offset + subresource_obj = _py_anon_pod33.from_ptr(addr, owner=self, readonly=subresource_readonly) + subresource_list.append(subresource_obj) + self._subresource = tuple(subresource_list) if self._data.size == 1: return self._subresource[0] return self._subresource @@ -20957,12 +20954,23 @@ cdef class ArrayMapInfo_v1: cdef _py_anon_pod33 val_ = val if self._data.size != 1: raise ValueError("Assign to the member of one element, e.g. array[i].subresource = value") - cdef intptr_t addr = self._data.subresource[0].__array_interface__['data'][0] + cdef intptr_t addr = _cyb_array_ptr(self._data) + array_map_info_v1_dtype.fields["subresource"][1] _cyb_memcpy(addr, (val_._get_ptr()), sizeof(cuda_bindings_driver__anon_pod33) * 1) @property def mem_handle(self): """_py_anon_pod36: """ + if self._mem_handle is None: + mem_handle_list = list() + mem_handle_base = _cyb_array_ptr(self._data) + mem_handle_offset = array_map_info_v1_dtype.fields["mem_handle"][1] + mem_handle_stride = self._data.strides[0] + mem_handle_readonly = not self._data.flags.writeable + for i in range(self._data.size): + addr = mem_handle_base + i * mem_handle_stride + mem_handle_offset + mem_handle_obj = _py_anon_pod36.from_ptr(addr, owner=self, readonly=mem_handle_readonly) + mem_handle_list.append(mem_handle_obj) + self._mem_handle = tuple(mem_handle_list) if self._data.size == 1: return self._mem_handle[0] return self._mem_handle @@ -20974,103 +20982,104 @@ cdef class ArrayMapInfo_v1: cdef _py_anon_pod36 val_ = val if self._data.size != 1: raise ValueError("Assign to the member of one element, e.g. array[i].mem_handle = value") - cdef intptr_t addr = self._data.mem_handle[0].__array_interface__['data'][0] + cdef intptr_t addr = _cyb_array_ptr(self._data) + array_map_info_v1_dtype.fields["mem_handle"][1] _cyb_memcpy(addr, (val_._get_ptr()), sizeof(cuda_bindings_driver__anon_pod36) * 1) @property def resource_type(self): """Union[~_numpy.int32, int]: """ if self._data.size == 1: - return int(self._data.resource_type[0]) - return self._data.resource_type + return int(self._data["resource_type"][0]) + return self._data["resource_type"] @resource_type.setter def resource_type(self, val): if not self._data.flags.writeable: raise ValueError("This ArrayMapInfo_v1 instance is read-only") - self._data.resource_type = val + self._data["resource_type"] = val @property def subresource_type(self): """Union[~_numpy.int32, int]: """ if self._data.size == 1: - return int(self._data.subresource_type[0]) - return self._data.subresource_type + return int(self._data["subresource_type"][0]) + return self._data["subresource_type"] @subresource_type.setter def subresource_type(self, val): if not self._data.flags.writeable: raise ValueError("This ArrayMapInfo_v1 instance is read-only") - self._data.subresource_type = val + self._data["subresource_type"] = val @property def mem_operation_type(self): """Union[~_numpy.int32, int]: """ if self._data.size == 1: - return int(self._data.mem_operation_type[0]) - return self._data.mem_operation_type + return int(self._data["mem_operation_type"][0]) + return self._data["mem_operation_type"] @mem_operation_type.setter def mem_operation_type(self, val): if not self._data.flags.writeable: raise ValueError("This ArrayMapInfo_v1 instance is read-only") - self._data.mem_operation_type = val + self._data["mem_operation_type"] = val @property def mem_handle_type(self): """Union[~_numpy.int32, int]: """ if self._data.size == 1: - return int(self._data.mem_handle_type[0]) - return self._data.mem_handle_type + return int(self._data["mem_handle_type"][0]) + return self._data["mem_handle_type"] @mem_handle_type.setter def mem_handle_type(self, val): if not self._data.flags.writeable: raise ValueError("This ArrayMapInfo_v1 instance is read-only") - self._data.mem_handle_type = val + self._data["mem_handle_type"] = val @property def offset(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.offset[0]) - return self._data.offset + return int(self._data["offset"][0]) + return self._data["offset"] @offset.setter def offset(self, val): if not self._data.flags.writeable: raise ValueError("This ArrayMapInfo_v1 instance is read-only") - self._data.offset = val + self._data["offset"] = val @property def device_bit_mask(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.device_bit_mask[0]) - return self._data.device_bit_mask + return int(self._data["device_bit_mask"][0]) + return self._data["device_bit_mask"] @device_bit_mask.setter def device_bit_mask(self, val): if not self._data.flags.writeable: raise ValueError("This ArrayMapInfo_v1 instance is read-only") - self._data.device_bit_mask = val + self._data["device_bit_mask"] = val @property def flags_(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.flags_[0]) - return self._data.flags_ + return int(self._data["flags_"][0]) + return self._data["flags_"] @flags_.setter def flags_(self, val): if not self._data.flags.writeable: raise ValueError("This ArrayMapInfo_v1 instance is read-only") - self._data.flags_ = val + self._data["flags_"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef ArrayMapInfo_v1 obj if isinstance(key, int): key_ = key size = self._data.size @@ -21078,10 +21087,18 @@ cdef class ArrayMapInfo_v1: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return ArrayMapInfo_v1.from_data(self._data[key_:key_+1]) + obj = ArrayMapInfo_v1.__new__(ArrayMapInfo_v1) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == array_map_info_v1_dtype: - return ArrayMapInfo_v1.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == array_map_info_v1_dtype: + obj = ArrayMapInfo_v1.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -21106,26 +21123,7 @@ cdef class ArrayMapInfo_v1: raise ValueError("data array must be 1D") if data.dtype != array_map_info_v1_dtype: raise ValueError("data array must be of dtype array_map_info_v1_dtype") - obj._data = data.view(_numpy.recarray) - - resource_list = list() - for i in range(obj._data.size): - addr = obj._data.resource[i].__array_interface__['data'][0] - resource_obj = _py_anon_pod32.from_ptr(addr, owner=obj, readonly=False) - resource_list.append(resource_obj) - obj._resource = tuple(resource_list) - subresource_list = list() - for i in range(obj._data.size): - addr = obj._data.subresource[i].__array_interface__['data'][0] - subresource_obj = _py_anon_pod33.from_ptr(addr, owner=obj, readonly=False) - subresource_list.append(subresource_obj) - obj._subresource = tuple(subresource_list) - mem_handle_list = list() - for i in range(obj._data.size): - addr = obj._data.mem_handle[i].__array_interface__['data'][0] - mem_handle_obj = _py_anon_pod36.from_ptr(addr, owner=obj, readonly=False) - mem_handle_list.append(mem_handle_obj) - obj._mem_handle = tuple(mem_handle_list) + obj._data = data.view(dtype=array_map_info_v1_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -21145,28 +21143,8 @@ cdef class ArrayMapInfo_v1: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(CUarrayMapInfo_v1) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=array_map_info_v1_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=array_map_info_v1_dtype_record) obj._owner = owner - - resource_list = list() - for i in range(obj._data.size): - addr = obj._data.resource[i].__array_interface__['data'][0] - resource_obj = _py_anon_pod32.from_ptr(addr, owner=obj, readonly=readonly) - resource_list.append(resource_obj) - obj._resource = tuple(resource_list) - subresource_list = list() - for i in range(obj._data.size): - addr = obj._data.subresource[i].__array_interface__['data'][0] - subresource_obj = _py_anon_pod33.from_ptr(addr, owner=obj, readonly=readonly) - subresource_list.append(subresource_obj) - obj._subresource = tuple(subresource_list) - mem_handle_list = list() - for i in range(obj._data.size): - addr = obj._data.mem_handle[i].__array_interface__['data'][0] - mem_handle_obj = _py_anon_pod36.from_ptr(addr, owner=obj, readonly=readonly) - mem_handle_list.append(mem_handle_obj) - obj._mem_handle = tuple(mem_handle_list) return obj @@ -21619,6 +21597,7 @@ cdef _get_dev_resource_v1_dtype_offsets(): }) dev_resource_v1_dtype = _get_dev_resource_v1_dtype_offsets() +cdef object dev_resource_v1_dtype_record = _numpy.dtype((_numpy.record, dev_resource_v1_dtype)) cdef class DevResource_v1: """Empty-initialize an array of `CUdevResource_v1`. @@ -21638,29 +21617,9 @@ cdef class DevResource_v1: readonly tuple _wq def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=dev_resource_v1_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=dev_resource_v1_dtype_record) assert self._data.itemsize == sizeof(CUdevResource_v1), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(CUdevResource_v1) }" - obj = self - sm_list = list() - for i in range(obj._data.size): - addr = obj._data.sm[i].__array_interface__['data'][0] - sm_obj = DevSmResource.from_ptr(addr, owner=obj, readonly=False) - sm_list.append(sm_obj) - obj._sm = tuple(sm_list) - wq_config_list = list() - for i in range(obj._data.size): - addr = obj._data.wq_config[i].__array_interface__['data'][0] - wq_config_obj = DevWorkqueueConfigResource.from_ptr(addr, owner=obj, readonly=False) - wq_config_list.append(wq_config_obj) - obj._wq_config = tuple(wq_config_list) - wq_list = list() - for i in range(obj._data.size): - addr = obj._data.wq[i].__array_interface__['data'][0] - wq_obj = DevWorkqueueResource.from_ptr(addr, owner=obj, readonly=False) - wq_list.append(wq_obj) - obj._wq = tuple(wq_list) def __repr__(self): if self._data.size > 1: @@ -21671,17 +21630,17 @@ cdef class DevResource_v1: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -21701,6 +21660,17 @@ cdef class DevResource_v1: @property def sm(self): """DevSmResource: """ + if self._sm is None: + sm_list = list() + sm_base = _cyb_array_ptr(self._data) + sm_offset = dev_resource_v1_dtype.fields["sm"][1] + sm_stride = self._data.strides[0] + sm_readonly = not self._data.flags.writeable + for i in range(self._data.size): + addr = sm_base + i * sm_stride + sm_offset + sm_obj = DevSmResource.from_ptr(addr, owner=self, readonly=sm_readonly) + sm_list.append(sm_obj) + self._sm = tuple(sm_list) if self._data.size == 1: return self._sm[0] return self._sm @@ -21712,12 +21682,23 @@ cdef class DevResource_v1: cdef DevSmResource val_ = val if self._data.size != 1: raise ValueError("Assign to the member of one element, e.g. array[i].sm = value") - cdef intptr_t addr = self._data.sm[0].__array_interface__['data'][0] + cdef intptr_t addr = _cyb_array_ptr(self._data) + dev_resource_v1_dtype.fields["sm"][1] _cyb_memcpy(addr, (val_._get_ptr()), sizeof(CUdevSmResource) * 1) @property def wq_config(self): """DevWorkqueueConfigResource: """ + if self._wq_config is None: + wq_config_list = list() + wq_config_base = _cyb_array_ptr(self._data) + wq_config_offset = dev_resource_v1_dtype.fields["wq_config"][1] + wq_config_stride = self._data.strides[0] + wq_config_readonly = not self._data.flags.writeable + for i in range(self._data.size): + addr = wq_config_base + i * wq_config_stride + wq_config_offset + wq_config_obj = DevWorkqueueConfigResource.from_ptr(addr, owner=self, readonly=wq_config_readonly) + wq_config_list.append(wq_config_obj) + self._wq_config = tuple(wq_config_list) if self._data.size == 1: return self._wq_config[0] return self._wq_config @@ -21729,12 +21710,23 @@ cdef class DevResource_v1: cdef DevWorkqueueConfigResource val_ = val if self._data.size != 1: raise ValueError("Assign to the member of one element, e.g. array[i].wq_config = value") - cdef intptr_t addr = self._data.wq_config[0].__array_interface__['data'][0] + cdef intptr_t addr = _cyb_array_ptr(self._data) + dev_resource_v1_dtype.fields["wq_config"][1] _cyb_memcpy(addr, (val_._get_ptr()), sizeof(CUdevWorkqueueConfigResource) * 1) @property def wq(self): """DevWorkqueueResource: """ + if self._wq is None: + wq_list = list() + wq_base = _cyb_array_ptr(self._data) + wq_offset = dev_resource_v1_dtype.fields["wq"][1] + wq_stride = self._data.strides[0] + wq_readonly = not self._data.flags.writeable + for i in range(self._data.size): + addr = wq_base + i * wq_stride + wq_offset + wq_obj = DevWorkqueueResource.from_ptr(addr, owner=self, readonly=wq_readonly) + wq_list.append(wq_obj) + self._wq = tuple(wq_list) if self._data.size == 1: return self._wq[0] return self._wq @@ -21746,60 +21738,61 @@ cdef class DevResource_v1: cdef DevWorkqueueResource val_ = val if self._data.size != 1: raise ValueError("Assign to the member of one element, e.g. array[i].wq = value") - cdef intptr_t addr = self._data.wq[0].__array_interface__['data'][0] + cdef intptr_t addr = _cyb_array_ptr(self._data) + dev_resource_v1_dtype.fields["wq"][1] _cyb_memcpy(addr, (val_._get_ptr()), sizeof(CUdevWorkqueueResource) * 1) @property def type(self): """Union[~_numpy.int32, int]: """ if self._data.size == 1: - return int(self._data.type[0]) - return self._data.type + return int(self._data["type"][0]) + return self._data["type"] @type.setter def type(self, val): if not self._data.flags.writeable: raise ValueError("This DevResource_v1 instance is read-only") - self._data.type = val + self._data["type"] = val @property def _internal_padding(self): """~_numpy.uint8: (array of length 92).""" - return self._data._internal_padding + return self._data["_internal_padding"] @_internal_padding.setter def _internal_padding(self, val): if not self._data.flags.writeable: raise ValueError("This DevResource_v1 instance is read-only") - self._data._internal_padding = val + self._data["_internal_padding"] = val @property def _oversize(self): """~_numpy.uint8: (array of length 40).""" - return self._data._oversize + return self._data["_oversize"] @_oversize.setter def _oversize(self, val): if not self._data.flags.writeable: raise ValueError("This DevResource_v1 instance is read-only") - self._data._oversize = val + self._data["_oversize"] = val @property def next_resource(self): """Union[~_numpy.intp, int]: """ if self._data.size == 1: - return int(self._data.next_resource[0]) - return self._data.next_resource + return int(self._data["next_resource"][0]) + return self._data["next_resource"] @next_resource.setter def next_resource(self, val): if not self._data.flags.writeable: raise ValueError("This DevResource_v1 instance is read-only") - self._data.next_resource = val + self._data["next_resource"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef DevResource_v1 obj if isinstance(key, int): key_ = key size = self._data.size @@ -21807,10 +21800,18 @@ cdef class DevResource_v1: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return DevResource_v1.from_data(self._data[key_:key_+1]) + obj = DevResource_v1.__new__(DevResource_v1) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == dev_resource_v1_dtype: - return DevResource_v1.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == dev_resource_v1_dtype: + obj = DevResource_v1.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -21835,26 +21836,7 @@ cdef class DevResource_v1: raise ValueError("data array must be 1D") if data.dtype != dev_resource_v1_dtype: raise ValueError("data array must be of dtype dev_resource_v1_dtype") - obj._data = data.view(_numpy.recarray) - - sm_list = list() - for i in range(obj._data.size): - addr = obj._data.sm[i].__array_interface__['data'][0] - sm_obj = DevSmResource.from_ptr(addr, owner=obj, readonly=False) - sm_list.append(sm_obj) - obj._sm = tuple(sm_list) - wq_config_list = list() - for i in range(obj._data.size): - addr = obj._data.wq_config[i].__array_interface__['data'][0] - wq_config_obj = DevWorkqueueConfigResource.from_ptr(addr, owner=obj, readonly=False) - wq_config_list.append(wq_config_obj) - obj._wq_config = tuple(wq_config_list) - wq_list = list() - for i in range(obj._data.size): - addr = obj._data.wq[i].__array_interface__['data'][0] - wq_obj = DevWorkqueueResource.from_ptr(addr, owner=obj, readonly=False) - wq_list.append(wq_obj) - obj._wq = tuple(wq_list) + obj._data = data.view(dtype=dev_resource_v1_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -21874,28 +21856,8 @@ cdef class DevResource_v1: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(CUdevResource_v1) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=dev_resource_v1_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=dev_resource_v1_dtype_record) obj._owner = owner - - sm_list = list() - for i in range(obj._data.size): - addr = obj._data.sm[i].__array_interface__['data'][0] - sm_obj = DevSmResource.from_ptr(addr, owner=obj, readonly=readonly) - sm_list.append(sm_obj) - obj._sm = tuple(sm_list) - wq_config_list = list() - for i in range(obj._data.size): - addr = obj._data.wq_config[i].__array_interface__['data'][0] - wq_config_obj = DevWorkqueueConfigResource.from_ptr(addr, owner=obj, readonly=readonly) - wq_config_list.append(wq_config_obj) - obj._wq_config = tuple(wq_config_list) - wq_list = list() - for i in range(obj._data.size): - addr = obj._data.wq[i].__array_interface__['data'][0] - wq_obj = DevWorkqueueResource.from_ptr(addr, owner=obj, readonly=readonly) - wq_list.append(wq_obj) - obj._wq = tuple(wq_list) return obj @@ -23674,6 +23636,7 @@ cdef _get_mem_access_desc_v1_dtype_offsets(): }) mem_access_desc_v1_dtype = _get_mem_access_desc_v1_dtype_offsets() +cdef object mem_access_desc_v1_dtype_record = _numpy.dtype((_numpy.record, mem_access_desc_v1_dtype)) cdef class MemAccessDesc_v1: """Empty-initialize an array of `CUmemAccessDesc_v1`. @@ -23691,17 +23654,9 @@ cdef class MemAccessDesc_v1: readonly tuple _location def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=mem_access_desc_v1_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=mem_access_desc_v1_dtype_record) assert self._data.itemsize == sizeof(CUmemAccessDesc_v1), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(CUmemAccessDesc_v1) }" - obj = self - location_list = list() - for i in range(obj._data.size): - addr = obj._data.location[i].__array_interface__['data'][0] - location_obj = MemLocation_v1.from_ptr(addr, owner=obj, readonly=False) - location_list.append(location_obj) - obj._location = tuple(location_list) def __repr__(self): if self._data.size > 1: @@ -23712,17 +23667,17 @@ cdef class MemAccessDesc_v1: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -23742,6 +23697,17 @@ cdef class MemAccessDesc_v1: @property def location(self): """MemLocation_v1: """ + if self._location is None: + location_list = list() + location_base = _cyb_array_ptr(self._data) + location_offset = mem_access_desc_v1_dtype.fields["location"][1] + location_stride = self._data.strides[0] + location_readonly = not self._data.flags.writeable + for i in range(self._data.size): + addr = location_base + i * location_stride + location_offset + location_obj = MemLocation_v1.from_ptr(addr, owner=self, readonly=location_readonly) + location_list.append(location_obj) + self._location = tuple(location_list) if self._data.size == 1: return self._location[0] return self._location @@ -23753,25 +23719,26 @@ cdef class MemAccessDesc_v1: cdef MemLocation_v1 val_ = val if self._data.size != 1: raise ValueError("Assign to the member of one element, e.g. array[i].location = value") - cdef intptr_t addr = self._data.location[0].__array_interface__['data'][0] + cdef intptr_t addr = _cyb_array_ptr(self._data) + mem_access_desc_v1_dtype.fields["location"][1] _cyb_memcpy(addr, (val_._get_ptr()), sizeof(CUmemLocation) * 1) @property def flags_(self): """Union[~_numpy.int32, int]: """ if self._data.size == 1: - return int(self._data.flags_[0]) - return self._data.flags_ + return int(self._data["flags_"][0]) + return self._data["flags_"] @flags_.setter def flags_(self, val): if not self._data.flags.writeable: raise ValueError("This MemAccessDesc_v1 instance is read-only") - self._data.flags_ = val + self._data["flags_"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef MemAccessDesc_v1 obj if isinstance(key, int): key_ = key size = self._data.size @@ -23779,10 +23746,18 @@ cdef class MemAccessDesc_v1: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return MemAccessDesc_v1.from_data(self._data[key_:key_+1]) + obj = MemAccessDesc_v1.__new__(MemAccessDesc_v1) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == mem_access_desc_v1_dtype: - return MemAccessDesc_v1.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == mem_access_desc_v1_dtype: + obj = MemAccessDesc_v1.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -23807,14 +23782,7 @@ cdef class MemAccessDesc_v1: raise ValueError("data array must be 1D") if data.dtype != mem_access_desc_v1_dtype: raise ValueError("data array must be of dtype mem_access_desc_v1_dtype") - obj._data = data.view(_numpy.recarray) - - location_list = list() - for i in range(obj._data.size): - addr = obj._data.location[i].__array_interface__['data'][0] - location_obj = MemLocation_v1.from_ptr(addr, owner=obj, readonly=False) - location_list.append(location_obj) - obj._location = tuple(location_list) + obj._data = data.view(dtype=mem_access_desc_v1_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -23834,16 +23802,8 @@ cdef class MemAccessDesc_v1: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(CUmemAccessDesc_v1) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=mem_access_desc_v1_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=mem_access_desc_v1_dtype_record) obj._owner = owner - - location_list = list() - for i in range(obj._data.size): - addr = obj._data.location[i].__array_interface__['data'][0] - location_obj = MemLocation_v1.from_ptr(addr, owner=obj, readonly=readonly) - location_list.append(location_obj) - obj._location = tuple(location_list) return obj diff --git a/cuda_bindings_13/cuda/bindings/cufile.pyx b/cuda_bindings_13/cuda/bindings/cufile.pyx index fff8d3061c0..d88ac812ef4 100644 --- a/cuda_bindings_13/cuda/bindings/cufile.pyx +++ b/cuda_bindings_13/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.4.1. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=43b7b2b1fd18625de44c30075928dabc5433911817f30d9d25f02d243c3aef88 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=51aa8097269246ec75ca06d0fd4f4ba97a110908146a66dfed09997c052406f3 # <<<< PREAMBLE CONTENT >>>> @@ -51,6 +51,14 @@ cdef _cyb___getbuffer(object self, _cyb_cpython.Py_buffer *buffer, void *ptr, in buffer.strides = &buffer.itemsize buffer.suboffsets = NULL +cdef inline intptr_t _cyb_array_ptr(object arr) except? 0: + cdef _cyb_cpython.Py_buffer view + cdef intptr_t ptr + _cyb_cpython.PyObject_GetBuffer(arr, &view, _cyb_cpython_buffer.PyBUF_STRIDES) + ptr = view.buf + _cyb_cpython.PyBuffer_Release(&view) + return ptr + cdef _cyb_from_buffer(buffer, size, lowpp_type): cdef _cyb_cpython.Py_buffer view if _cyb_cpython.PyObject_GetBuffer(buffer, &view, _cyb_cpython_buffer.PyBUF_SIMPLE) != 0: @@ -428,6 +436,7 @@ cdef _get_io_events_dtype_offsets(): }) io_events_dtype = _get_io_events_dtype_offsets() +cdef object io_events_dtype_record = _numpy.dtype((_numpy.record, io_events_dtype)) cdef class IOEvents: """Empty-initialize an array of `CUfileIOEvents_t`. @@ -444,8 +453,7 @@ cdef class IOEvents: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=io_events_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=io_events_dtype_record) assert self._data.itemsize == sizeof(CUfileIOEvents_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(CUfileIOEvents_t) }" @@ -458,17 +466,17 @@ cdef class IOEvents: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -489,44 +497,45 @@ cdef class IOEvents: def cookie(self): """Union[~_numpy.intp, int]: """ if self._data.size == 1: - return int(self._data.cookie[0]) - return self._data.cookie + return int(self._data["cookie"][0]) + return self._data["cookie"] @cookie.setter def cookie(self, val): if not self._data.flags.writeable: raise ValueError("This IOEvents instance is read-only") - self._data.cookie = val + self._data["cookie"] = val @property def status(self): """Union[~_numpy.int32, int]: """ if self._data.size == 1: - return int(self._data.status[0]) - return self._data.status + return int(self._data["status"][0]) + return self._data["status"] @status.setter def status(self, val): if not self._data.flags.writeable: raise ValueError("This IOEvents instance is read-only") - self._data.status = val + self._data["status"] = val @property def ret(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.ret[0]) - return self._data.ret + return int(self._data["ret"][0]) + return self._data["ret"] @ret.setter def ret(self, val): if not self._data.flags.writeable: raise ValueError("This IOEvents instance is read-only") - self._data.ret = val + self._data["ret"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef IOEvents obj if isinstance(key, int): key_ = key size = self._data.size @@ -534,10 +543,18 @@ cdef class IOEvents: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return IOEvents.from_data(self._data[key_:key_+1]) + obj = IOEvents.__new__(IOEvents) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == io_events_dtype: - return IOEvents.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == io_events_dtype: + obj = IOEvents.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -562,8 +579,7 @@ cdef class IOEvents: raise ValueError("data array must be 1D") if data.dtype != io_events_dtype: raise ValueError("data array must be of dtype io_events_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=io_events_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -583,10 +599,8 @@ cdef class IOEvents: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(CUfileIOEvents_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=io_events_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=io_events_dtype_record) obj._owner = owner - return obj @@ -780,6 +794,7 @@ cdef _get_per_gpu_stats_dtype_offsets(): }) per_gpu_stats_dtype = _get_per_gpu_stats_dtype_offsets() +cdef object per_gpu_stats_dtype_record = _numpy.dtype((_numpy.record, per_gpu_stats_dtype)) cdef class PerGpuStats: """Empty-initialize an array of `CUfilePerGpuStats_t`. @@ -796,8 +811,7 @@ cdef class PerGpuStats: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=per_gpu_stats_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=per_gpu_stats_dtype_record) assert self._data.itemsize == sizeof(CUfilePerGpuStats_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(CUfilePerGpuStats_t) }" @@ -810,17 +824,17 @@ cdef class PerGpuStats: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -840,394 +854,395 @@ cdef class PerGpuStats: @property def uuid(self): """~_numpy.int8: (array of length 16).""" - return self._data.uuid + return self._data["uuid"] @uuid.setter def uuid(self, val): if not self._data.flags.writeable: raise ValueError("This PerGpuStats instance is read-only") - self._data.uuid = val + self._data["uuid"] = val @property def read_bytes(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.read_bytes[0]) - return self._data.read_bytes + return int(self._data["read_bytes"][0]) + return self._data["read_bytes"] @read_bytes.setter def read_bytes(self, val): if not self._data.flags.writeable: raise ValueError("This PerGpuStats instance is read-only") - self._data.read_bytes = val + self._data["read_bytes"] = val @property def read_bw_bytes_per_sec(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.read_bw_bytes_per_sec[0]) - return self._data.read_bw_bytes_per_sec + return int(self._data["read_bw_bytes_per_sec"][0]) + return self._data["read_bw_bytes_per_sec"] @read_bw_bytes_per_sec.setter def read_bw_bytes_per_sec(self, val): if not self._data.flags.writeable: raise ValueError("This PerGpuStats instance is read-only") - self._data.read_bw_bytes_per_sec = val + self._data["read_bw_bytes_per_sec"] = val @property def read_utilization(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.read_utilization[0]) - return self._data.read_utilization + return int(self._data["read_utilization"][0]) + return self._data["read_utilization"] @read_utilization.setter def read_utilization(self, val): if not self._data.flags.writeable: raise ValueError("This PerGpuStats instance is read-only") - self._data.read_utilization = val + self._data["read_utilization"] = val @property def read_duration_us(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.read_duration_us[0]) - return self._data.read_duration_us + return int(self._data["read_duration_us"][0]) + return self._data["read_duration_us"] @read_duration_us.setter def read_duration_us(self, val): if not self._data.flags.writeable: raise ValueError("This PerGpuStats instance is read-only") - self._data.read_duration_us = val + self._data["read_duration_us"] = val @property def n_total_reads(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.n_total_reads[0]) - return self._data.n_total_reads + return int(self._data["n_total_reads"][0]) + return self._data["n_total_reads"] @n_total_reads.setter def n_total_reads(self, val): if not self._data.flags.writeable: raise ValueError("This PerGpuStats instance is read-only") - self._data.n_total_reads = val + self._data["n_total_reads"] = val @property def n_p2p_reads(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.n_p2p_reads[0]) - return self._data.n_p2p_reads + return int(self._data["n_p2p_reads"][0]) + return self._data["n_p2p_reads"] @n_p2p_reads.setter def n_p2p_reads(self, val): if not self._data.flags.writeable: raise ValueError("This PerGpuStats instance is read-only") - self._data.n_p2p_reads = val + self._data["n_p2p_reads"] = val @property def n_nvfs_reads(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.n_nvfs_reads[0]) - return self._data.n_nvfs_reads + return int(self._data["n_nvfs_reads"][0]) + return self._data["n_nvfs_reads"] @n_nvfs_reads.setter def n_nvfs_reads(self, val): if not self._data.flags.writeable: raise ValueError("This PerGpuStats instance is read-only") - self._data.n_nvfs_reads = val + self._data["n_nvfs_reads"] = val @property def n_posix_reads(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.n_posix_reads[0]) - return self._data.n_posix_reads + return int(self._data["n_posix_reads"][0]) + return self._data["n_posix_reads"] @n_posix_reads.setter def n_posix_reads(self, val): if not self._data.flags.writeable: raise ValueError("This PerGpuStats instance is read-only") - self._data.n_posix_reads = val + self._data["n_posix_reads"] = val @property def n_unaligned_reads(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.n_unaligned_reads[0]) - return self._data.n_unaligned_reads + return int(self._data["n_unaligned_reads"][0]) + return self._data["n_unaligned_reads"] @n_unaligned_reads.setter def n_unaligned_reads(self, val): if not self._data.flags.writeable: raise ValueError("This PerGpuStats instance is read-only") - self._data.n_unaligned_reads = val + self._data["n_unaligned_reads"] = val @property def n_dr_reads(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.n_dr_reads[0]) - return self._data.n_dr_reads + return int(self._data["n_dr_reads"][0]) + return self._data["n_dr_reads"] @n_dr_reads.setter def n_dr_reads(self, val): if not self._data.flags.writeable: raise ValueError("This PerGpuStats instance is read-only") - self._data.n_dr_reads = val + self._data["n_dr_reads"] = val @property def n_sparse_regions(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.n_sparse_regions[0]) - return self._data.n_sparse_regions + return int(self._data["n_sparse_regions"][0]) + return self._data["n_sparse_regions"] @n_sparse_regions.setter def n_sparse_regions(self, val): if not self._data.flags.writeable: raise ValueError("This PerGpuStats instance is read-only") - self._data.n_sparse_regions = val + self._data["n_sparse_regions"] = val @property def n_inline_regions(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.n_inline_regions[0]) - return self._data.n_inline_regions + return int(self._data["n_inline_regions"][0]) + return self._data["n_inline_regions"] @n_inline_regions.setter def n_inline_regions(self, val): if not self._data.flags.writeable: raise ValueError("This PerGpuStats instance is read-only") - self._data.n_inline_regions = val + self._data["n_inline_regions"] = val @property def n_reads_err(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.n_reads_err[0]) - return self._data.n_reads_err + return int(self._data["n_reads_err"][0]) + return self._data["n_reads_err"] @n_reads_err.setter def n_reads_err(self, val): if not self._data.flags.writeable: raise ValueError("This PerGpuStats instance is read-only") - self._data.n_reads_err = val + self._data["n_reads_err"] = val @property def writes_bytes(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.writes_bytes[0]) - return self._data.writes_bytes + return int(self._data["writes_bytes"][0]) + return self._data["writes_bytes"] @writes_bytes.setter def writes_bytes(self, val): if not self._data.flags.writeable: raise ValueError("This PerGpuStats instance is read-only") - self._data.writes_bytes = val + self._data["writes_bytes"] = val @property def write_bw_bytes_per_sec(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.write_bw_bytes_per_sec[0]) - return self._data.write_bw_bytes_per_sec + return int(self._data["write_bw_bytes_per_sec"][0]) + return self._data["write_bw_bytes_per_sec"] @write_bw_bytes_per_sec.setter def write_bw_bytes_per_sec(self, val): if not self._data.flags.writeable: raise ValueError("This PerGpuStats instance is read-only") - self._data.write_bw_bytes_per_sec = val + self._data["write_bw_bytes_per_sec"] = val @property def write_utilization(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.write_utilization[0]) - return self._data.write_utilization + return int(self._data["write_utilization"][0]) + return self._data["write_utilization"] @write_utilization.setter def write_utilization(self, val): if not self._data.flags.writeable: raise ValueError("This PerGpuStats instance is read-only") - self._data.write_utilization = val + self._data["write_utilization"] = val @property def write_duration_us(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.write_duration_us[0]) - return self._data.write_duration_us + return int(self._data["write_duration_us"][0]) + return self._data["write_duration_us"] @write_duration_us.setter def write_duration_us(self, val): if not self._data.flags.writeable: raise ValueError("This PerGpuStats instance is read-only") - self._data.write_duration_us = val + self._data["write_duration_us"] = val @property def n_total_writes(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.n_total_writes[0]) - return self._data.n_total_writes + return int(self._data["n_total_writes"][0]) + return self._data["n_total_writes"] @n_total_writes.setter def n_total_writes(self, val): if not self._data.flags.writeable: raise ValueError("This PerGpuStats instance is read-only") - self._data.n_total_writes = val + self._data["n_total_writes"] = val @property def n_p2p_writes(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.n_p2p_writes[0]) - return self._data.n_p2p_writes + return int(self._data["n_p2p_writes"][0]) + return self._data["n_p2p_writes"] @n_p2p_writes.setter def n_p2p_writes(self, val): if not self._data.flags.writeable: raise ValueError("This PerGpuStats instance is read-only") - self._data.n_p2p_writes = val + self._data["n_p2p_writes"] = val @property def n_nvfs_writes(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.n_nvfs_writes[0]) - return self._data.n_nvfs_writes + return int(self._data["n_nvfs_writes"][0]) + return self._data["n_nvfs_writes"] @n_nvfs_writes.setter def n_nvfs_writes(self, val): if not self._data.flags.writeable: raise ValueError("This PerGpuStats instance is read-only") - self._data.n_nvfs_writes = val + self._data["n_nvfs_writes"] = val @property def n_posix_writes(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.n_posix_writes[0]) - return self._data.n_posix_writes + return int(self._data["n_posix_writes"][0]) + return self._data["n_posix_writes"] @n_posix_writes.setter def n_posix_writes(self, val): if not self._data.flags.writeable: raise ValueError("This PerGpuStats instance is read-only") - self._data.n_posix_writes = val + self._data["n_posix_writes"] = val @property def n_unaligned_writes(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.n_unaligned_writes[0]) - return self._data.n_unaligned_writes + return int(self._data["n_unaligned_writes"][0]) + return self._data["n_unaligned_writes"] @n_unaligned_writes.setter def n_unaligned_writes(self, val): if not self._data.flags.writeable: raise ValueError("This PerGpuStats instance is read-only") - self._data.n_unaligned_writes = val + self._data["n_unaligned_writes"] = val @property def n_dr_writes(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.n_dr_writes[0]) - return self._data.n_dr_writes + return int(self._data["n_dr_writes"][0]) + return self._data["n_dr_writes"] @n_dr_writes.setter def n_dr_writes(self, val): if not self._data.flags.writeable: raise ValueError("This PerGpuStats instance is read-only") - self._data.n_dr_writes = val + self._data["n_dr_writes"] = val @property def n_writes_err(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.n_writes_err[0]) - return self._data.n_writes_err + return int(self._data["n_writes_err"][0]) + return self._data["n_writes_err"] @n_writes_err.setter def n_writes_err(self, val): if not self._data.flags.writeable: raise ValueError("This PerGpuStats instance is read-only") - self._data.n_writes_err = val + self._data["n_writes_err"] = val @property def n_mmap(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.n_mmap[0]) - return self._data.n_mmap + return int(self._data["n_mmap"][0]) + return self._data["n_mmap"] @n_mmap.setter def n_mmap(self, val): if not self._data.flags.writeable: raise ValueError("This PerGpuStats instance is read-only") - self._data.n_mmap = val + self._data["n_mmap"] = val @property def n_mmap_ok(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.n_mmap_ok[0]) - return self._data.n_mmap_ok + return int(self._data["n_mmap_ok"][0]) + return self._data["n_mmap_ok"] @n_mmap_ok.setter def n_mmap_ok(self, val): if not self._data.flags.writeable: raise ValueError("This PerGpuStats instance is read-only") - self._data.n_mmap_ok = val + self._data["n_mmap_ok"] = val @property def n_mmap_err(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.n_mmap_err[0]) - return self._data.n_mmap_err + return int(self._data["n_mmap_err"][0]) + return self._data["n_mmap_err"] @n_mmap_err.setter def n_mmap_err(self, val): if not self._data.flags.writeable: raise ValueError("This PerGpuStats instance is read-only") - self._data.n_mmap_err = val + self._data["n_mmap_err"] = val @property def n_mmap_free(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.n_mmap_free[0]) - return self._data.n_mmap_free + return int(self._data["n_mmap_free"][0]) + return self._data["n_mmap_free"] @n_mmap_free.setter def n_mmap_free(self, val): if not self._data.flags.writeable: raise ValueError("This PerGpuStats instance is read-only") - self._data.n_mmap_free = val + self._data["n_mmap_free"] = val @property def reg_bytes(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.reg_bytes[0]) - return self._data.reg_bytes + return int(self._data["reg_bytes"][0]) + return self._data["reg_bytes"] @reg_bytes.setter def reg_bytes(self, val): if not self._data.flags.writeable: raise ValueError("This PerGpuStats instance is read-only") - self._data.reg_bytes = val + self._data["reg_bytes"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef PerGpuStats obj if isinstance(key, int): key_ = key size = self._data.size @@ -1235,10 +1250,18 @@ cdef class PerGpuStats: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return PerGpuStats.from_data(self._data[key_:key_+1]) + obj = PerGpuStats.__new__(PerGpuStats) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == per_gpu_stats_dtype: - return PerGpuStats.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == per_gpu_stats_dtype: + obj = PerGpuStats.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -1263,8 +1286,7 @@ cdef class PerGpuStats: raise ValueError("data array must be 1D") if data.dtype != per_gpu_stats_dtype: raise ValueError("data array must be of dtype per_gpu_stats_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=per_gpu_stats_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -1284,10 +1306,8 @@ cdef class PerGpuStats: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(CUfilePerGpuStats_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=per_gpu_stats_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=per_gpu_stats_dtype_record) obj._owner = owner - return obj @@ -1304,6 +1324,7 @@ cdef _get_io_vec_dtype_offsets(): }) io_vec_dtype = _get_io_vec_dtype_offsets() +cdef object io_vec_dtype_record = _numpy.dtype((_numpy.record, io_vec_dtype)) cdef class IOVec: """Empty-initialize an array of `CUfileIOVec_t`. @@ -1320,8 +1341,7 @@ cdef class IOVec: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=io_vec_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=io_vec_dtype_record) assert self._data.itemsize == sizeof(CUfileIOVec_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(CUfileIOVec_t) }" @@ -1334,17 +1354,17 @@ cdef class IOVec: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -1365,31 +1385,32 @@ cdef class IOVec: def base_(self): """Union[~_numpy.intp, int]: """ if self._data.size == 1: - return int(self._data.base_[0]) - return self._data.base_ + return int(self._data["base_"][0]) + return self._data["base_"] @base_.setter def base_(self, val): if not self._data.flags.writeable: raise ValueError("This IOVec instance is read-only") - self._data.base_ = val + self._data["base_"] = val @property def len(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.len[0]) - return self._data.len + return int(self._data["len"][0]) + return self._data["len"] @len.setter def len(self, val): if not self._data.flags.writeable: raise ValueError("This IOVec instance is read-only") - self._data.len = val + self._data["len"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef IOVec obj if isinstance(key, int): key_ = key size = self._data.size @@ -1397,10 +1418,18 @@ cdef class IOVec: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return IOVec.from_data(self._data[key_:key_+1]) + obj = IOVec.__new__(IOVec) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == io_vec_dtype: - return IOVec.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == io_vec_dtype: + obj = IOVec.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -1425,8 +1454,7 @@ cdef class IOVec: raise ValueError("data array must be 1D") if data.dtype != io_vec_dtype: raise ValueError("data array must be of dtype io_vec_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=io_vec_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -1446,10 +1474,8 @@ cdef class IOVec: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(CUfileIOVec_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=io_vec_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=io_vec_dtype_record) obj._owner = owner - return obj @@ -1467,6 +1493,7 @@ cdef _get_descr_dtype_offsets(): }) descr_dtype = _get_descr_dtype_offsets() +cdef object descr_dtype_record = _numpy.dtype((_numpy.record, descr_dtype)) cdef class Descr: """Empty-initialize an array of `CUfileDescr_t`. @@ -1483,8 +1510,7 @@ cdef class Descr: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=descr_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=descr_dtype_record) assert self._data.itemsize == sizeof(CUfileDescr_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(CUfileDescr_t) }" @@ -1497,17 +1523,17 @@ cdef class Descr: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -1528,42 +1554,43 @@ cdef class Descr: def type(self): """Union[~_numpy.int32, int]: """ if self._data.size == 1: - return int(self._data.type[0]) - return self._data.type + return int(self._data["type"][0]) + return self._data["type"] @type.setter def type(self, val): if not self._data.flags.writeable: raise ValueError("This Descr instance is read-only") - self._data.type = val + self._data["type"] = val @property def handle(self): """_py_anon_pod1_dtype: """ - return self._data.handle + return self._data["handle"].view(_numpy.recarray) @handle.setter def handle(self, val): if not self._data.flags.writeable: raise ValueError("This Descr instance is read-only") - self._data.handle = val + self._data["handle"] = val @property def fs_ops(self): """Union[~_numpy.intp, int]: """ if self._data.size == 1: - return int(self._data.fs_ops[0]) - return self._data.fs_ops + return int(self._data["fs_ops"][0]) + return self._data["fs_ops"] @fs_ops.setter def fs_ops(self, val): if not self._data.flags.writeable: raise ValueError("This Descr instance is read-only") - self._data.fs_ops = val + self._data["fs_ops"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef Descr obj if isinstance(key, int): key_ = key size = self._data.size @@ -1571,10 +1598,18 @@ cdef class Descr: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return Descr.from_data(self._data[key_:key_+1]) + obj = Descr.__new__(Descr) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == descr_dtype: - return Descr.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == descr_dtype: + obj = Descr.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -1599,8 +1634,7 @@ cdef class Descr: raise ValueError("data array must be 1D") if data.dtype != descr_dtype: raise ValueError("data array must be of dtype descr_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=descr_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -1620,10 +1654,8 @@ cdef class Descr: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(CUfileDescr_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=descr_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=descr_dtype_record) obj._owner = owner - return obj @@ -2685,6 +2717,7 @@ cdef _get_io_params_dtype_offsets(): }) io_params_dtype = _get_io_params_dtype_offsets() +cdef object io_params_dtype_record = _numpy.dtype((_numpy.record, io_params_dtype)) cdef class IOParams: """Empty-initialize an array of `CUfileIOParams_t`. @@ -2701,8 +2734,7 @@ cdef class IOParams: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=io_params_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=io_params_dtype_record) assert self._data.itemsize == sizeof(CUfileIOParams_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(CUfileIOParams_t) }" @@ -2715,17 +2747,17 @@ cdef class IOParams: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -2746,68 +2778,69 @@ cdef class IOParams: def mode(self): """Union[~_numpy.int32, int]: """ if self._data.size == 1: - return int(self._data.mode[0]) - return self._data.mode + return int(self._data["mode"][0]) + return self._data["mode"] @mode.setter def mode(self, val): if not self._data.flags.writeable: raise ValueError("This IOParams instance is read-only") - self._data.mode = val + self._data["mode"] = val @property def u(self): """_py_anon_pod2_dtype: """ - return self._data.u + return self._data["u"].view(_numpy.recarray) @u.setter def u(self, val): if not self._data.flags.writeable: raise ValueError("This IOParams instance is read-only") - self._data.u = val + self._data["u"] = val @property def fh(self): """Union[~_numpy.intp, int]: """ if self._data.size == 1: - return int(self._data.fh[0]) - return self._data.fh + return int(self._data["fh"][0]) + return self._data["fh"] @fh.setter def fh(self, val): if not self._data.flags.writeable: raise ValueError("This IOParams instance is read-only") - self._data.fh = val + self._data["fh"] = val @property def opcode(self): """Union[~_numpy.int32, int]: """ if self._data.size == 1: - return int(self._data.opcode[0]) - return self._data.opcode + return int(self._data["opcode"][0]) + return self._data["opcode"] @opcode.setter def opcode(self, val): if not self._data.flags.writeable: raise ValueError("This IOParams instance is read-only") - self._data.opcode = val + self._data["opcode"] = val @property def cookie(self): """Union[~_numpy.intp, int]: """ if self._data.size == 1: - return int(self._data.cookie[0]) - return self._data.cookie + return int(self._data["cookie"][0]) + return self._data["cookie"] @cookie.setter def cookie(self, val): if not self._data.flags.writeable: raise ValueError("This IOParams instance is read-only") - self._data.cookie = val + self._data["cookie"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef IOParams obj if isinstance(key, int): key_ = key size = self._data.size @@ -2815,10 +2848,18 @@ cdef class IOParams: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return IOParams.from_data(self._data[key_:key_+1]) + obj = IOParams.__new__(IOParams) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == io_params_dtype: - return IOParams.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == io_params_dtype: + obj = IOParams.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -2843,8 +2884,7 @@ cdef class IOParams: raise ValueError("data array must be 1D") if data.dtype != io_params_dtype: raise ValueError("data array must be of dtype io_params_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=io_params_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -2864,10 +2904,8 @@ cdef class IOParams: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(CUfileIOParams_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=io_params_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=io_params_dtype_record) obj._owner = owner - return obj diff --git a/cuda_bindings_13/cuda/bindings/cycufile.pxd b/cuda_bindings_13/cuda/bindings/cycufile.pxd index a25708f54d6..0daa8e4ebd6 100644 --- a/cuda_bindings_13/cuda/bindings/cycufile.pxd +++ b/cuda_bindings_13/cuda/bindings/cycufile.pxd @@ -3,20 +3,20 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.1 to 13.4.1. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=3162b8877d941d81077ca9b42527585c22ed7e727b87389f9649b3ebf22d6ec9 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=0f9f241649c57abeccbf6b668c54cbeaa1c2fa990ff783bfc114b617a7773aba # <<<< PREAMBLE CONTENT >>>> -cdef extern from "": - pass - from libc.stdint cimport ( uint32_t, uint64_t, ) from libcpp cimport bool as _cyb_bool +cdef extern from "": + pass + # <<<< END OF PREAMBLE CONTENT >>>> diff --git a/cuda_bindings_13/cuda/bindings/cydriver.pxd b/cuda_bindings_13/cuda/bindings/cydriver.pxd index 0a4918ab8c5..e399609ff07 100644 --- a/cuda_bindings_13/cuda/bindings/cydriver.pxd +++ b/cuda_bindings_13/cuda/bindings/cydriver.pxd @@ -3,19 +3,19 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.0 to 13.4.1. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=650abadba73a2c94411e41b2ae235092bef45e6db706202bb779d8e8dd118375 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=76bc92829a6025611352b8808094ca11e65a8544a0ac60687fbd65d282d7aa77 # <<<< PREAMBLE CONTENT >>>> -cdef extern from "": - pass - from libc.stdint cimport ( uint32_t, uint64_t, ) +cdef extern from "": + pass + # <<<< END OF PREAMBLE CONTENT >>>> diff --git a/cuda_bindings_13/cuda/bindings/nvml.pyx b/cuda_bindings_13/cuda/bindings/nvml.pyx index 7f18f98977e..42e1b8bd222 100644 --- a/cuda_bindings_13/cuda/bindings/nvml.pyx +++ b/cuda_bindings_13/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.4.1. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=5c3afec4f14f03303533c7e373c24a624243ebed2e91d50bf9617d546d0297bc +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=b9fa4fb6c95c7d5ac8e8a53cc16619a8a1012a0e30bb53b850d9afc19ea9fd67 # <<<< PREAMBLE CONTENT >>>> @@ -47,6 +47,14 @@ cdef _cyb___getbuffer(object self, _cyb_cpython.Py_buffer *buffer, void *ptr, in buffer.strides = &buffer.itemsize buffer.suboffsets = NULL +cdef inline intptr_t _cyb_array_ptr(object arr) except? 0: + cdef _cyb_cpython.Py_buffer view + cdef intptr_t ptr + _cyb_cpython.PyObject_GetBuffer(arr, &view, _cyb_cpython_buffer.PyBUF_STRIDES) + ptr = view.buf + _cyb_cpython.PyBuffer_Release(&view) + return ptr + cdef _cyb_from_buffer(buffer, size, lowpp_type): cdef _cyb_cpython.Py_buffer view if _cyb_cpython.PyObject_GetBuffer(buffer, &view, _cyb_cpython_buffer.PyBUF_SIMPLE) != 0: @@ -4156,6 +4164,7 @@ cdef _get_process_info_dtype_offsets(): }) process_info_dtype = _get_process_info_dtype_offsets() +cdef object process_info_dtype_record = _numpy.dtype((_numpy.record, process_info_dtype)) cdef class ProcessInfo: """Empty-initialize an array of `nvmlProcessInfo_t`. @@ -4172,8 +4181,7 @@ cdef class ProcessInfo: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=process_info_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=process_info_dtype_record) assert self._data.itemsize == sizeof(nvmlProcessInfo_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlProcessInfo_t) }" @@ -4186,17 +4194,17 @@ cdef class ProcessInfo: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -4217,57 +4225,58 @@ cdef class ProcessInfo: def pid(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.pid[0]) - return self._data.pid + return int(self._data["pid"][0]) + return self._data["pid"] @pid.setter def pid(self, val): if not self._data.flags.writeable: raise ValueError("This ProcessInfo instance is read-only") - self._data.pid = val + self._data["pid"] = val @property def used_gpu_memory(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.used_gpu_memory[0]) - return self._data.used_gpu_memory + return int(self._data["used_gpu_memory"][0]) + return self._data["used_gpu_memory"] @used_gpu_memory.setter def used_gpu_memory(self, val): if not self._data.flags.writeable: raise ValueError("This ProcessInfo instance is read-only") - self._data.used_gpu_memory = val + self._data["used_gpu_memory"] = val @property def gpu_instance_id(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.gpu_instance_id[0]) - return self._data.gpu_instance_id + return int(self._data["gpu_instance_id"][0]) + return self._data["gpu_instance_id"] @gpu_instance_id.setter def gpu_instance_id(self, val): if not self._data.flags.writeable: raise ValueError("This ProcessInfo instance is read-only") - self._data.gpu_instance_id = val + self._data["gpu_instance_id"] = val @property def compute_instance_id(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.compute_instance_id[0]) - return self._data.compute_instance_id + return int(self._data["compute_instance_id"][0]) + return self._data["compute_instance_id"] @compute_instance_id.setter def compute_instance_id(self, val): if not self._data.flags.writeable: raise ValueError("This ProcessInfo instance is read-only") - self._data.compute_instance_id = val + self._data["compute_instance_id"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef ProcessInfo obj if isinstance(key, int): key_ = key size = self._data.size @@ -4275,10 +4284,18 @@ cdef class ProcessInfo: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return ProcessInfo.from_data(self._data[key_:key_+1]) + obj = ProcessInfo.__new__(ProcessInfo) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == process_info_dtype: - return ProcessInfo.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == process_info_dtype: + obj = ProcessInfo.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -4303,8 +4320,7 @@ cdef class ProcessInfo: raise ValueError("data array must be 1D") if data.dtype != process_info_dtype: raise ValueError("data array must be of dtype process_info_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=process_info_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -4324,10 +4340,8 @@ cdef class ProcessInfo: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlProcessInfo_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=process_info_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=process_info_dtype_record) obj._owner = owner - return obj @@ -4347,6 +4361,7 @@ cdef _get_process_detail_v1_dtype_offsets(): }) process_detail_v1_dtype = _get_process_detail_v1_dtype_offsets() +cdef object process_detail_v1_dtype_record = _numpy.dtype((_numpy.record, process_detail_v1_dtype)) cdef class ProcessDetail_v1: """Empty-initialize an array of `nvmlProcessDetail_v1_t`. @@ -4363,8 +4378,7 @@ cdef class ProcessDetail_v1: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=process_detail_v1_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=process_detail_v1_dtype_record) assert self._data.itemsize == sizeof(nvmlProcessDetail_v1_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlProcessDetail_v1_t) }" @@ -4377,17 +4391,17 @@ cdef class ProcessDetail_v1: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -4408,70 +4422,71 @@ cdef class ProcessDetail_v1: def pid(self): """Union[~_numpy.uint32, int]: Process ID.""" if self._data.size == 1: - return int(self._data.pid[0]) - return self._data.pid + return int(self._data["pid"][0]) + return self._data["pid"] @pid.setter def pid(self, val): if not self._data.flags.writeable: raise ValueError("This ProcessDetail_v1 instance is read-only") - self._data.pid = val + self._data["pid"] = val @property def used_gpu_memory(self): """Union[~_numpy.uint64, int]: Amount of used GPU memory in bytes. Under WDDM, NVML_VALUE_NOT_AVAILABLE is always reported because Windows KMD manages all the memory and not the NVIDIA driver""" if self._data.size == 1: - return int(self._data.used_gpu_memory[0]) - return self._data.used_gpu_memory + return int(self._data["used_gpu_memory"][0]) + return self._data["used_gpu_memory"] @used_gpu_memory.setter def used_gpu_memory(self, val): if not self._data.flags.writeable: raise ValueError("This ProcessDetail_v1 instance is read-only") - self._data.used_gpu_memory = val + self._data["used_gpu_memory"] = val @property def gpu_instance_id(self): """Union[~_numpy.uint32, int]: If MIG is enabled, stores a valid GPU instance ID. gpuInstanceId is.""" if self._data.size == 1: - return int(self._data.gpu_instance_id[0]) - return self._data.gpu_instance_id + return int(self._data["gpu_instance_id"][0]) + return self._data["gpu_instance_id"] @gpu_instance_id.setter def gpu_instance_id(self, val): if not self._data.flags.writeable: raise ValueError("This ProcessDetail_v1 instance is read-only") - self._data.gpu_instance_id = val + self._data["gpu_instance_id"] = val @property def compute_instance_id(self): """Union[~_numpy.uint32, int]: If MIG is enabled, stores a valid compute instance ID. computeInstanceId.""" if self._data.size == 1: - return int(self._data.compute_instance_id[0]) - return self._data.compute_instance_id + return int(self._data["compute_instance_id"][0]) + return self._data["compute_instance_id"] @compute_instance_id.setter def compute_instance_id(self, val): if not self._data.flags.writeable: raise ValueError("This ProcessDetail_v1 instance is read-only") - self._data.compute_instance_id = val + self._data["compute_instance_id"] = val @property def used_gpu_cc_protected_memory(self): """Union[~_numpy.uint64, int]: Amount of used GPU conf compute protected memory in bytes.""" if self._data.size == 1: - return int(self._data.used_gpu_cc_protected_memory[0]) - return self._data.used_gpu_cc_protected_memory + return int(self._data["used_gpu_cc_protected_memory"][0]) + return self._data["used_gpu_cc_protected_memory"] @used_gpu_cc_protected_memory.setter def used_gpu_cc_protected_memory(self, val): if not self._data.flags.writeable: raise ValueError("This ProcessDetail_v1 instance is read-only") - self._data.used_gpu_cc_protected_memory = val + self._data["used_gpu_cc_protected_memory"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef ProcessDetail_v1 obj if isinstance(key, int): key_ = key size = self._data.size @@ -4479,10 +4494,18 @@ cdef class ProcessDetail_v1: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return ProcessDetail_v1.from_data(self._data[key_:key_+1]) + obj = ProcessDetail_v1.__new__(ProcessDetail_v1) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == process_detail_v1_dtype: - return ProcessDetail_v1.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == process_detail_v1_dtype: + obj = ProcessDetail_v1.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -4507,8 +4530,7 @@ cdef class ProcessDetail_v1: raise ValueError("data array must be 1D") if data.dtype != process_detail_v1_dtype: raise ValueError("data array must be of dtype process_detail_v1_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=process_detail_v1_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -4528,10 +4550,8 @@ cdef class ProcessDetail_v1: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlProcessDetail_v1_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=process_detail_v1_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=process_detail_v1_dtype_record) obj._owner = owner - return obj @@ -5067,6 +5087,7 @@ cdef _get_bridge_chip_info_dtype_offsets(): }) bridge_chip_info_dtype = _get_bridge_chip_info_dtype_offsets() +cdef object bridge_chip_info_dtype_record = _numpy.dtype((_numpy.record, bridge_chip_info_dtype)) cdef class BridgeChipInfo: """Empty-initialize an array of `nvmlBridgeChipInfo_t`. @@ -5083,8 +5104,7 @@ cdef class BridgeChipInfo: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=bridge_chip_info_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=bridge_chip_info_dtype_record) assert self._data.itemsize == sizeof(nvmlBridgeChipInfo_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlBridgeChipInfo_t) }" @@ -5097,17 +5117,17 @@ cdef class BridgeChipInfo: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -5128,31 +5148,32 @@ cdef class BridgeChipInfo: def type(self): """Union[~_numpy.int32, int]: """ if self._data.size == 1: - return int(self._data.type[0]) - return self._data.type + return int(self._data["type"][0]) + return self._data["type"] @type.setter def type(self, val): if not self._data.flags.writeable: raise ValueError("This BridgeChipInfo instance is read-only") - self._data.type = val + self._data["type"] = val @property def fw_version(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.fw_version[0]) - return self._data.fw_version + return int(self._data["fw_version"][0]) + return self._data["fw_version"] @fw_version.setter def fw_version(self, val): if not self._data.flags.writeable: raise ValueError("This BridgeChipInfo instance is read-only") - self._data.fw_version = val + self._data["fw_version"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef BridgeChipInfo obj if isinstance(key, int): key_ = key size = self._data.size @@ -5160,10 +5181,18 @@ cdef class BridgeChipInfo: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return BridgeChipInfo.from_data(self._data[key_:key_+1]) + obj = BridgeChipInfo.__new__(BridgeChipInfo) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == bridge_chip_info_dtype: - return BridgeChipInfo.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == bridge_chip_info_dtype: + obj = BridgeChipInfo.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -5188,8 +5217,7 @@ cdef class BridgeChipInfo: raise ValueError("data array must be 1D") if data.dtype != bridge_chip_info_dtype: raise ValueError("data array must be of dtype bridge_chip_info_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=bridge_chip_info_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -5209,10 +5237,8 @@ cdef class BridgeChipInfo: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlBridgeChipInfo_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=bridge_chip_info_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=bridge_chip_info_dtype_record) obj._owner = owner - return obj @@ -5441,6 +5467,7 @@ cdef _get__py_anon_pod0_dtype_offsets(): }) _py_anon_pod0_dtype = _get__py_anon_pod0_dtype_offsets() +cdef object _py_anon_pod0_dtype_record = _numpy.dtype((_numpy.record, _py_anon_pod0_dtype)) cdef class _py_anon_pod0: """Empty-initialize an array of `cuda_bindings_nvml__anon_pod0`. @@ -5457,8 +5484,7 @@ cdef class _py_anon_pod0: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=_py_anon_pod0_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=_py_anon_pod0_dtype_record) assert self._data.itemsize == sizeof(cuda_bindings_nvml__anon_pod0), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(cuda_bindings_nvml__anon_pod0) }" @@ -5471,17 +5497,17 @@ cdef class _py_anon_pod0: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -5502,70 +5528,71 @@ cdef class _py_anon_pod0: def controller(self): """Union[~_numpy.int32, int]: """ if self._data.size == 1: - return int(self._data.controller[0]) - return self._data.controller + return int(self._data["controller"][0]) + return self._data["controller"] @controller.setter def controller(self, val): if not self._data.flags.writeable: raise ValueError("This _py_anon_pod0 instance is read-only") - self._data.controller = val + self._data["controller"] = val @property def default_min_temp(self): """Union[~_numpy.int32, int]: """ if self._data.size == 1: - return int(self._data.default_min_temp[0]) - return self._data.default_min_temp + return int(self._data["default_min_temp"][0]) + return self._data["default_min_temp"] @default_min_temp.setter def default_min_temp(self, val): if not self._data.flags.writeable: raise ValueError("This _py_anon_pod0 instance is read-only") - self._data.default_min_temp = val + self._data["default_min_temp"] = val @property def default_max_temp(self): """Union[~_numpy.int32, int]: """ if self._data.size == 1: - return int(self._data.default_max_temp[0]) - return self._data.default_max_temp + return int(self._data["default_max_temp"][0]) + return self._data["default_max_temp"] @default_max_temp.setter def default_max_temp(self, val): if not self._data.flags.writeable: raise ValueError("This _py_anon_pod0 instance is read-only") - self._data.default_max_temp = val + self._data["default_max_temp"] = val @property def current_temp(self): """Union[~_numpy.int32, int]: """ if self._data.size == 1: - return int(self._data.current_temp[0]) - return self._data.current_temp + return int(self._data["current_temp"][0]) + return self._data["current_temp"] @current_temp.setter def current_temp(self, val): if not self._data.flags.writeable: raise ValueError("This _py_anon_pod0 instance is read-only") - self._data.current_temp = val + self._data["current_temp"] = val @property def target(self): """Union[~_numpy.int32, int]: """ if self._data.size == 1: - return int(self._data.target[0]) - return self._data.target + return int(self._data["target"][0]) + return self._data["target"] @target.setter def target(self, val): if not self._data.flags.writeable: raise ValueError("This _py_anon_pod0 instance is read-only") - self._data.target = val + self._data["target"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef _py_anon_pod0 obj if isinstance(key, int): key_ = key size = self._data.size @@ -5573,10 +5600,18 @@ cdef class _py_anon_pod0: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return _py_anon_pod0.from_data(self._data[key_:key_+1]) + obj = _py_anon_pod0.__new__(_py_anon_pod0) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == _py_anon_pod0_dtype: - return _py_anon_pod0.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == _py_anon_pod0_dtype: + obj = _py_anon_pod0.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -5601,8 +5636,7 @@ cdef class _py_anon_pod0: raise ValueError("data array must be 1D") if data.dtype != _py_anon_pod0_dtype: raise ValueError("data array must be of dtype _py_anon_pod0_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=_py_anon_pod0_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -5622,10 +5656,8 @@ cdef class _py_anon_pod0: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(cuda_bindings_nvml__anon_pod0) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=_py_anon_pod0_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=_py_anon_pod0_dtype_record) obj._owner = owner - return obj @@ -5803,6 +5835,7 @@ cdef _get_clk_mon_fault_info_dtype_offsets(): }) clk_mon_fault_info_dtype = _get_clk_mon_fault_info_dtype_offsets() +cdef object clk_mon_fault_info_dtype_record = _numpy.dtype((_numpy.record, clk_mon_fault_info_dtype)) cdef class ClkMonFaultInfo: """Empty-initialize an array of `nvmlClkMonFaultInfo_t`. @@ -5819,8 +5852,7 @@ cdef class ClkMonFaultInfo: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=clk_mon_fault_info_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=clk_mon_fault_info_dtype_record) assert self._data.itemsize == sizeof(nvmlClkMonFaultInfo_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlClkMonFaultInfo_t) }" @@ -5833,17 +5865,17 @@ cdef class ClkMonFaultInfo: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -5864,31 +5896,32 @@ cdef class ClkMonFaultInfo: def clk_api_domain(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.clk_api_domain[0]) - return self._data.clk_api_domain + return int(self._data["clk_api_domain"][0]) + return self._data["clk_api_domain"] @clk_api_domain.setter def clk_api_domain(self, val): if not self._data.flags.writeable: raise ValueError("This ClkMonFaultInfo instance is read-only") - self._data.clk_api_domain = val + self._data["clk_api_domain"] = val @property def clk_domain_fault_mask(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.clk_domain_fault_mask[0]) - return self._data.clk_domain_fault_mask + return int(self._data["clk_domain_fault_mask"][0]) + return self._data["clk_domain_fault_mask"] @clk_domain_fault_mask.setter def clk_domain_fault_mask(self, val): if not self._data.flags.writeable: raise ValueError("This ClkMonFaultInfo instance is read-only") - self._data.clk_domain_fault_mask = val + self._data["clk_domain_fault_mask"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef ClkMonFaultInfo obj if isinstance(key, int): key_ = key size = self._data.size @@ -5896,10 +5929,18 @@ cdef class ClkMonFaultInfo: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return ClkMonFaultInfo.from_data(self._data[key_:key_+1]) + obj = ClkMonFaultInfo.__new__(ClkMonFaultInfo) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == clk_mon_fault_info_dtype: - return ClkMonFaultInfo.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == clk_mon_fault_info_dtype: + obj = ClkMonFaultInfo.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -5924,8 +5965,7 @@ cdef class ClkMonFaultInfo: raise ValueError("data array must be 1D") if data.dtype != clk_mon_fault_info_dtype: raise ValueError("data array must be of dtype clk_mon_fault_info_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=clk_mon_fault_info_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -5945,10 +5985,8 @@ cdef class ClkMonFaultInfo: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlClkMonFaultInfo_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=clk_mon_fault_info_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=clk_mon_fault_info_dtype_record) obj._owner = owner - return obj @@ -6154,6 +6192,7 @@ cdef _get_process_utilization_sample_dtype_offsets(): }) process_utilization_sample_dtype = _get_process_utilization_sample_dtype_offsets() +cdef object process_utilization_sample_dtype_record = _numpy.dtype((_numpy.record, process_utilization_sample_dtype)) cdef class ProcessUtilizationSample: """Empty-initialize an array of `nvmlProcessUtilizationSample_t`. @@ -6170,8 +6209,7 @@ cdef class ProcessUtilizationSample: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=process_utilization_sample_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=process_utilization_sample_dtype_record) assert self._data.itemsize == sizeof(nvmlProcessUtilizationSample_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlProcessUtilizationSample_t) }" @@ -6184,17 +6222,17 @@ cdef class ProcessUtilizationSample: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -6215,83 +6253,84 @@ cdef class ProcessUtilizationSample: def pid(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.pid[0]) - return self._data.pid + return int(self._data["pid"][0]) + return self._data["pid"] @pid.setter def pid(self, val): if not self._data.flags.writeable: raise ValueError("This ProcessUtilizationSample instance is read-only") - self._data.pid = val + self._data["pid"] = val @property def time_stamp(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.time_stamp[0]) - return self._data.time_stamp + return int(self._data["time_stamp"][0]) + return self._data["time_stamp"] @time_stamp.setter def time_stamp(self, val): if not self._data.flags.writeable: raise ValueError("This ProcessUtilizationSample instance is read-only") - self._data.time_stamp = val + self._data["time_stamp"] = val @property def sm_util(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.sm_util[0]) - return self._data.sm_util + return int(self._data["sm_util"][0]) + return self._data["sm_util"] @sm_util.setter def sm_util(self, val): if not self._data.flags.writeable: raise ValueError("This ProcessUtilizationSample instance is read-only") - self._data.sm_util = val + self._data["sm_util"] = val @property def mem_util(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.mem_util[0]) - return self._data.mem_util + return int(self._data["mem_util"][0]) + return self._data["mem_util"] @mem_util.setter def mem_util(self, val): if not self._data.flags.writeable: raise ValueError("This ProcessUtilizationSample instance is read-only") - self._data.mem_util = val + self._data["mem_util"] = val @property def enc_util(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.enc_util[0]) - return self._data.enc_util + return int(self._data["enc_util"][0]) + return self._data["enc_util"] @enc_util.setter def enc_util(self, val): if not self._data.flags.writeable: raise ValueError("This ProcessUtilizationSample instance is read-only") - self._data.enc_util = val + self._data["enc_util"] = val @property def dec_util(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.dec_util[0]) - return self._data.dec_util + return int(self._data["dec_util"][0]) + return self._data["dec_util"] @dec_util.setter def dec_util(self, val): if not self._data.flags.writeable: raise ValueError("This ProcessUtilizationSample instance is read-only") - self._data.dec_util = val + self._data["dec_util"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef ProcessUtilizationSample obj if isinstance(key, int): key_ = key size = self._data.size @@ -6299,10 +6338,18 @@ cdef class ProcessUtilizationSample: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return ProcessUtilizationSample.from_data(self._data[key_:key_+1]) + obj = ProcessUtilizationSample.__new__(ProcessUtilizationSample) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == process_utilization_sample_dtype: - return ProcessUtilizationSample.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == process_utilization_sample_dtype: + obj = ProcessUtilizationSample.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -6327,8 +6374,7 @@ cdef class ProcessUtilizationSample: raise ValueError("data array must be 1D") if data.dtype != process_utilization_sample_dtype: raise ValueError("data array must be of dtype process_utilization_sample_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=process_utilization_sample_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -6348,10 +6394,8 @@ cdef class ProcessUtilizationSample: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlProcessUtilizationSample_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=process_utilization_sample_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=process_utilization_sample_dtype_record) obj._owner = owner - return obj @@ -6374,6 +6418,7 @@ cdef _get_process_utilization_info_v1_dtype_offsets(): }) process_utilization_info_v1_dtype = _get_process_utilization_info_v1_dtype_offsets() +cdef object process_utilization_info_v1_dtype_record = _numpy.dtype((_numpy.record, process_utilization_info_v1_dtype)) cdef class ProcessUtilizationInfo_v1: """Empty-initialize an array of `nvmlProcessUtilizationInfo_v1_t`. @@ -6390,8 +6435,7 @@ cdef class ProcessUtilizationInfo_v1: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=process_utilization_info_v1_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=process_utilization_info_v1_dtype_record) assert self._data.itemsize == sizeof(nvmlProcessUtilizationInfo_v1_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlProcessUtilizationInfo_v1_t) }" @@ -6404,17 +6448,17 @@ cdef class ProcessUtilizationInfo_v1: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -6435,109 +6479,110 @@ cdef class ProcessUtilizationInfo_v1: def time_stamp(self): """Union[~_numpy.uint64, int]: CPU Timestamp in microseconds.""" if self._data.size == 1: - return int(self._data.time_stamp[0]) - return self._data.time_stamp + return int(self._data["time_stamp"][0]) + return self._data["time_stamp"] @time_stamp.setter def time_stamp(self, val): if not self._data.flags.writeable: raise ValueError("This ProcessUtilizationInfo_v1 instance is read-only") - self._data.time_stamp = val + self._data["time_stamp"] = val @property def pid(self): """Union[~_numpy.uint32, int]: PID of process.""" if self._data.size == 1: - return int(self._data.pid[0]) - return self._data.pid + return int(self._data["pid"][0]) + return self._data["pid"] @pid.setter def pid(self, val): if not self._data.flags.writeable: raise ValueError("This ProcessUtilizationInfo_v1 instance is read-only") - self._data.pid = val + self._data["pid"] = val @property def sm_util(self): """Union[~_numpy.uint32, int]: SM (3D/Compute) Util Value.""" if self._data.size == 1: - return int(self._data.sm_util[0]) - return self._data.sm_util + return int(self._data["sm_util"][0]) + return self._data["sm_util"] @sm_util.setter def sm_util(self, val): if not self._data.flags.writeable: raise ValueError("This ProcessUtilizationInfo_v1 instance is read-only") - self._data.sm_util = val + self._data["sm_util"] = val @property def mem_util(self): """Union[~_numpy.uint32, int]: Frame Buffer Memory Util Value.""" if self._data.size == 1: - return int(self._data.mem_util[0]) - return self._data.mem_util + return int(self._data["mem_util"][0]) + return self._data["mem_util"] @mem_util.setter def mem_util(self, val): if not self._data.flags.writeable: raise ValueError("This ProcessUtilizationInfo_v1 instance is read-only") - self._data.mem_util = val + self._data["mem_util"] = val @property def enc_util(self): """Union[~_numpy.uint32, int]: Encoder Util Value.""" if self._data.size == 1: - return int(self._data.enc_util[0]) - return self._data.enc_util + return int(self._data["enc_util"][0]) + return self._data["enc_util"] @enc_util.setter def enc_util(self, val): if not self._data.flags.writeable: raise ValueError("This ProcessUtilizationInfo_v1 instance is read-only") - self._data.enc_util = val + self._data["enc_util"] = val @property def dec_util(self): """Union[~_numpy.uint32, int]: Decoder Util Value.""" if self._data.size == 1: - return int(self._data.dec_util[0]) - return self._data.dec_util + return int(self._data["dec_util"][0]) + return self._data["dec_util"] @dec_util.setter def dec_util(self, val): if not self._data.flags.writeable: raise ValueError("This ProcessUtilizationInfo_v1 instance is read-only") - self._data.dec_util = val + self._data["dec_util"] = val @property def jpg_util(self): """Union[~_numpy.uint32, int]: Jpeg Util Value.""" if self._data.size == 1: - return int(self._data.jpg_util[0]) - return self._data.jpg_util + return int(self._data["jpg_util"][0]) + return self._data["jpg_util"] @jpg_util.setter def jpg_util(self, val): if not self._data.flags.writeable: raise ValueError("This ProcessUtilizationInfo_v1 instance is read-only") - self._data.jpg_util = val + self._data["jpg_util"] = val @property def ofa_util(self): """Union[~_numpy.uint32, int]: Ofa Util Value.""" if self._data.size == 1: - return int(self._data.ofa_util[0]) - return self._data.ofa_util + return int(self._data["ofa_util"][0]) + return self._data["ofa_util"] @ofa_util.setter def ofa_util(self, val): if not self._data.flags.writeable: raise ValueError("This ProcessUtilizationInfo_v1 instance is read-only") - self._data.ofa_util = val + self._data["ofa_util"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef ProcessUtilizationInfo_v1 obj if isinstance(key, int): key_ = key size = self._data.size @@ -6545,10 +6590,18 @@ cdef class ProcessUtilizationInfo_v1: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return ProcessUtilizationInfo_v1.from_data(self._data[key_:key_+1]) + obj = ProcessUtilizationInfo_v1.__new__(ProcessUtilizationInfo_v1) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == process_utilization_info_v1_dtype: - return ProcessUtilizationInfo_v1.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == process_utilization_info_v1_dtype: + obj = ProcessUtilizationInfo_v1.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -6573,8 +6626,7 @@ cdef class ProcessUtilizationInfo_v1: raise ValueError("data array must be 1D") if data.dtype != process_utilization_info_v1_dtype: raise ValueError("data array must be of dtype process_utilization_info_v1_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=process_utilization_info_v1_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -6594,10 +6646,8 @@ cdef class ProcessUtilizationInfo_v1: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlProcessUtilizationInfo_v1_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=process_utilization_info_v1_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=process_utilization_info_v1_dtype_record) obj._owner = owner - return obj @@ -7327,6 +7377,7 @@ cdef _get__py_anon_pod1_dtype_offsets(): }) _py_anon_pod1_dtype = _get__py_anon_pod1_dtype_offsets() +cdef object _py_anon_pod1_dtype_record = _numpy.dtype((_numpy.record, _py_anon_pod1_dtype)) cdef class _py_anon_pod1: """Empty-initialize an array of `cuda_bindings_nvml__anon_pod1`. @@ -7343,8 +7394,7 @@ cdef class _py_anon_pod1: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=_py_anon_pod1_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=_py_anon_pod1_dtype_record) assert self._data.itemsize == sizeof(cuda_bindings_nvml__anon_pod1), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(cuda_bindings_nvml__anon_pod1) }" @@ -7357,17 +7407,17 @@ cdef class _py_anon_pod1: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -7388,57 +7438,58 @@ cdef class _py_anon_pod1: def b_is_present(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.b_is_present[0]) - return self._data.b_is_present + return int(self._data["b_is_present"][0]) + return self._data["b_is_present"] @b_is_present.setter def b_is_present(self, val): if not self._data.flags.writeable: raise ValueError("This _py_anon_pod1 instance is read-only") - self._data.b_is_present = val + self._data["b_is_present"] = val @property def percentage(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.percentage[0]) - return self._data.percentage + return int(self._data["percentage"][0]) + return self._data["percentage"] @percentage.setter def percentage(self, val): if not self._data.flags.writeable: raise ValueError("This _py_anon_pod1 instance is read-only") - self._data.percentage = val + self._data["percentage"] = val @property def inc_threshold(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.inc_threshold[0]) - return self._data.inc_threshold + return int(self._data["inc_threshold"][0]) + return self._data["inc_threshold"] @inc_threshold.setter def inc_threshold(self, val): if not self._data.flags.writeable: raise ValueError("This _py_anon_pod1 instance is read-only") - self._data.inc_threshold = val + self._data["inc_threshold"] = val @property def dec_threshold(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.dec_threshold[0]) - return self._data.dec_threshold + return int(self._data["dec_threshold"][0]) + return self._data["dec_threshold"] @dec_threshold.setter def dec_threshold(self, val): if not self._data.flags.writeable: raise ValueError("This _py_anon_pod1 instance is read-only") - self._data.dec_threshold = val + self._data["dec_threshold"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef _py_anon_pod1 obj if isinstance(key, int): key_ = key size = self._data.size @@ -7446,10 +7497,18 @@ cdef class _py_anon_pod1: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return _py_anon_pod1.from_data(self._data[key_:key_+1]) + obj = _py_anon_pod1.__new__(_py_anon_pod1) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == _py_anon_pod1_dtype: - return _py_anon_pod1.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == _py_anon_pod1_dtype: + obj = _py_anon_pod1.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -7474,8 +7533,7 @@ cdef class _py_anon_pod1: raise ValueError("data array must be 1D") if data.dtype != _py_anon_pod1_dtype: raise ValueError("data array must be of dtype _py_anon_pod1_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=_py_anon_pod1_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -7495,10 +7553,8 @@ cdef class _py_anon_pod1: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(cuda_bindings_nvml__anon_pod1) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=_py_anon_pod1_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=_py_anon_pod1_dtype_record) obj._owner = owner - return obj @@ -7831,6 +7887,7 @@ cdef _get_vgpu_process_utilization_sample_dtype_offsets(): }) vgpu_process_utilization_sample_dtype = _get_vgpu_process_utilization_sample_dtype_offsets() +cdef object vgpu_process_utilization_sample_dtype_record = _numpy.dtype((_numpy.record, vgpu_process_utilization_sample_dtype)) cdef class VgpuProcessUtilizationSample: """Empty-initialize an array of `nvmlVgpuProcessUtilizationSample_t`. @@ -7847,8 +7904,7 @@ cdef class VgpuProcessUtilizationSample: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=vgpu_process_utilization_sample_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=vgpu_process_utilization_sample_dtype_record) assert self._data.itemsize == sizeof(nvmlVgpuProcessUtilizationSample_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlVgpuProcessUtilizationSample_t) }" @@ -7861,17 +7917,17 @@ cdef class VgpuProcessUtilizationSample: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -7892,107 +7948,108 @@ cdef class VgpuProcessUtilizationSample: def vgpu_instance(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.vgpu_instance[0]) - return self._data.vgpu_instance + return int(self._data["vgpu_instance"][0]) + return self._data["vgpu_instance"] @vgpu_instance.setter def vgpu_instance(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuProcessUtilizationSample instance is read-only") - self._data.vgpu_instance = val + self._data["vgpu_instance"] = val @property def pid(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.pid[0]) - return self._data.pid + return int(self._data["pid"][0]) + return self._data["pid"] @pid.setter def pid(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuProcessUtilizationSample instance is read-only") - self._data.pid = val + self._data["pid"] = val @property def process_name(self): """~_numpy.int8: (array of length 64).""" - return self._data.process_name + return self._data["process_name"] @process_name.setter def process_name(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuProcessUtilizationSample instance is read-only") - self._data.process_name = val + self._data["process_name"] = val @property def time_stamp(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.time_stamp[0]) - return self._data.time_stamp + return int(self._data["time_stamp"][0]) + return self._data["time_stamp"] @time_stamp.setter def time_stamp(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuProcessUtilizationSample instance is read-only") - self._data.time_stamp = val + self._data["time_stamp"] = val @property def sm_util(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.sm_util[0]) - return self._data.sm_util + return int(self._data["sm_util"][0]) + return self._data["sm_util"] @sm_util.setter def sm_util(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuProcessUtilizationSample instance is read-only") - self._data.sm_util = val + self._data["sm_util"] = val @property def mem_util(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.mem_util[0]) - return self._data.mem_util + return int(self._data["mem_util"][0]) + return self._data["mem_util"] @mem_util.setter def mem_util(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuProcessUtilizationSample instance is read-only") - self._data.mem_util = val + self._data["mem_util"] = val @property def enc_util(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.enc_util[0]) - return self._data.enc_util + return int(self._data["enc_util"][0]) + return self._data["enc_util"] @enc_util.setter def enc_util(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuProcessUtilizationSample instance is read-only") - self._data.enc_util = val + self._data["enc_util"] = val @property def dec_util(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.dec_util[0]) - return self._data.dec_util + return int(self._data["dec_util"][0]) + return self._data["dec_util"] @dec_util.setter def dec_util(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuProcessUtilizationSample instance is read-only") - self._data.dec_util = val + self._data["dec_util"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef VgpuProcessUtilizationSample obj if isinstance(key, int): key_ = key size = self._data.size @@ -8000,10 +8057,18 @@ cdef class VgpuProcessUtilizationSample: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return VgpuProcessUtilizationSample.from_data(self._data[key_:key_+1]) + obj = VgpuProcessUtilizationSample.__new__(VgpuProcessUtilizationSample) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == vgpu_process_utilization_sample_dtype: - return VgpuProcessUtilizationSample.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == vgpu_process_utilization_sample_dtype: + obj = VgpuProcessUtilizationSample.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -8028,8 +8093,7 @@ cdef class VgpuProcessUtilizationSample: raise ValueError("data array must be 1D") if data.dtype != vgpu_process_utilization_sample_dtype: raise ValueError("data array must be of dtype vgpu_process_utilization_sample_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=vgpu_process_utilization_sample_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -8049,10 +8113,8 @@ cdef class VgpuProcessUtilizationSample: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlVgpuProcessUtilizationSample_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=vgpu_process_utilization_sample_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=vgpu_process_utilization_sample_dtype_record) obj._owner = owner - return obj @@ -8077,6 +8139,7 @@ cdef _get_vgpu_process_utilization_info_v1_dtype_offsets(): }) vgpu_process_utilization_info_v1_dtype = _get_vgpu_process_utilization_info_v1_dtype_offsets() +cdef object vgpu_process_utilization_info_v1_dtype_record = _numpy.dtype((_numpy.record, vgpu_process_utilization_info_v1_dtype)) cdef class VgpuProcessUtilizationInfo_v1: """Empty-initialize an array of `nvmlVgpuProcessUtilizationInfo_v1_t`. @@ -8093,8 +8156,7 @@ cdef class VgpuProcessUtilizationInfo_v1: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=vgpu_process_utilization_info_v1_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=vgpu_process_utilization_info_v1_dtype_record) assert self._data.itemsize == sizeof(nvmlVgpuProcessUtilizationInfo_v1_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlVgpuProcessUtilizationInfo_v1_t) }" @@ -8107,17 +8169,17 @@ cdef class VgpuProcessUtilizationInfo_v1: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -8137,134 +8199,135 @@ cdef class VgpuProcessUtilizationInfo_v1: @property def process_name(self): """~_numpy.int8: (array of length 64).Name of process running within the vGPU VM.""" - return self._data.process_name + return self._data["process_name"] @process_name.setter def process_name(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuProcessUtilizationInfo_v1 instance is read-only") - self._data.process_name = val + self._data["process_name"] = val @property def time_stamp(self): """Union[~_numpy.uint64, int]: CPU Timestamp in microseconds.""" if self._data.size == 1: - return int(self._data.time_stamp[0]) - return self._data.time_stamp + return int(self._data["time_stamp"][0]) + return self._data["time_stamp"] @time_stamp.setter def time_stamp(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuProcessUtilizationInfo_v1 instance is read-only") - self._data.time_stamp = val + self._data["time_stamp"] = val @property def vgpu_instance(self): """Union[~_numpy.uint32, int]: vGPU Instance""" if self._data.size == 1: - return int(self._data.vgpu_instance[0]) - return self._data.vgpu_instance + return int(self._data["vgpu_instance"][0]) + return self._data["vgpu_instance"] @vgpu_instance.setter def vgpu_instance(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuProcessUtilizationInfo_v1 instance is read-only") - self._data.vgpu_instance = val + self._data["vgpu_instance"] = val @property def pid(self): """Union[~_numpy.uint32, int]: PID of process running within the vGPU VM.""" if self._data.size == 1: - return int(self._data.pid[0]) - return self._data.pid + return int(self._data["pid"][0]) + return self._data["pid"] @pid.setter def pid(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuProcessUtilizationInfo_v1 instance is read-only") - self._data.pid = val + self._data["pid"] = val @property def sm_util(self): """Union[~_numpy.uint32, int]: SM (3D/Compute) Util Value.""" if self._data.size == 1: - return int(self._data.sm_util[0]) - return self._data.sm_util + return int(self._data["sm_util"][0]) + return self._data["sm_util"] @sm_util.setter def sm_util(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuProcessUtilizationInfo_v1 instance is read-only") - self._data.sm_util = val + self._data["sm_util"] = val @property def mem_util(self): """Union[~_numpy.uint32, int]: Frame Buffer Memory Util Value.""" if self._data.size == 1: - return int(self._data.mem_util[0]) - return self._data.mem_util + return int(self._data["mem_util"][0]) + return self._data["mem_util"] @mem_util.setter def mem_util(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuProcessUtilizationInfo_v1 instance is read-only") - self._data.mem_util = val + self._data["mem_util"] = val @property def enc_util(self): """Union[~_numpy.uint32, int]: Encoder Util Value.""" if self._data.size == 1: - return int(self._data.enc_util[0]) - return self._data.enc_util + return int(self._data["enc_util"][0]) + return self._data["enc_util"] @enc_util.setter def enc_util(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuProcessUtilizationInfo_v1 instance is read-only") - self._data.enc_util = val + self._data["enc_util"] = val @property def dec_util(self): """Union[~_numpy.uint32, int]: Decoder Util Value.""" if self._data.size == 1: - return int(self._data.dec_util[0]) - return self._data.dec_util + return int(self._data["dec_util"][0]) + return self._data["dec_util"] @dec_util.setter def dec_util(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuProcessUtilizationInfo_v1 instance is read-only") - self._data.dec_util = val + self._data["dec_util"] = val @property def jpg_util(self): """Union[~_numpy.uint32, int]: Jpeg Util Value.""" if self._data.size == 1: - return int(self._data.jpg_util[0]) - return self._data.jpg_util + return int(self._data["jpg_util"][0]) + return self._data["jpg_util"] @jpg_util.setter def jpg_util(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuProcessUtilizationInfo_v1 instance is read-only") - self._data.jpg_util = val + self._data["jpg_util"] = val @property def ofa_util(self): """Union[~_numpy.uint32, int]: Ofa Util Value.""" if self._data.size == 1: - return int(self._data.ofa_util[0]) - return self._data.ofa_util + return int(self._data["ofa_util"][0]) + return self._data["ofa_util"] @ofa_util.setter def ofa_util(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuProcessUtilizationInfo_v1 instance is read-only") - self._data.ofa_util = val + self._data["ofa_util"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef VgpuProcessUtilizationInfo_v1 obj if isinstance(key, int): key_ = key size = self._data.size @@ -8272,10 +8335,18 @@ cdef class VgpuProcessUtilizationInfo_v1: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return VgpuProcessUtilizationInfo_v1.from_data(self._data[key_:key_+1]) + obj = VgpuProcessUtilizationInfo_v1.__new__(VgpuProcessUtilizationInfo_v1) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == vgpu_process_utilization_info_v1_dtype: - return VgpuProcessUtilizationInfo_v1.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == vgpu_process_utilization_info_v1_dtype: + obj = VgpuProcessUtilizationInfo_v1.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -8300,8 +8371,7 @@ cdef class VgpuProcessUtilizationInfo_v1: raise ValueError("data array must be 1D") if data.dtype != vgpu_process_utilization_info_v1_dtype: raise ValueError("data array must be of dtype vgpu_process_utilization_info_v1_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=vgpu_process_utilization_info_v1_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -8321,10 +8391,8 @@ cdef class VgpuProcessUtilizationInfo_v1: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlVgpuProcessUtilizationInfo_v1_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=vgpu_process_utilization_info_v1_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=vgpu_process_utilization_info_v1_dtype_record) obj._owner = owner - return obj @@ -8631,6 +8699,7 @@ cdef _get_vgpu_scheduler_log_entry_dtype_offsets(): }) vgpu_scheduler_log_entry_dtype = _get_vgpu_scheduler_log_entry_dtype_offsets() +cdef object vgpu_scheduler_log_entry_dtype_record = _numpy.dtype((_numpy.record, vgpu_scheduler_log_entry_dtype)) cdef class VgpuSchedulerLogEntry: """Empty-initialize an array of `nvmlVgpuSchedulerLogEntry_t`. @@ -8647,8 +8716,7 @@ cdef class VgpuSchedulerLogEntry: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=vgpu_scheduler_log_entry_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=vgpu_scheduler_log_entry_dtype_record) assert self._data.itemsize == sizeof(nvmlVgpuSchedulerLogEntry_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlVgpuSchedulerLogEntry_t) }" @@ -8661,17 +8729,17 @@ cdef class VgpuSchedulerLogEntry: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -8692,83 +8760,84 @@ cdef class VgpuSchedulerLogEntry: def timestamp(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.timestamp[0]) - return self._data.timestamp + return int(self._data["timestamp"][0]) + return self._data["timestamp"] @timestamp.setter def timestamp(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuSchedulerLogEntry instance is read-only") - self._data.timestamp = val + self._data["timestamp"] = val @property def time_run_total(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.time_run_total[0]) - return self._data.time_run_total + return int(self._data["time_run_total"][0]) + return self._data["time_run_total"] @time_run_total.setter def time_run_total(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuSchedulerLogEntry instance is read-only") - self._data.time_run_total = val + self._data["time_run_total"] = val @property def time_run(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.time_run[0]) - return self._data.time_run + return int(self._data["time_run"][0]) + return self._data["time_run"] @time_run.setter def time_run(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuSchedulerLogEntry instance is read-only") - self._data.time_run = val + self._data["time_run"] = val @property def sw_runlist_id(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.sw_runlist_id[0]) - return self._data.sw_runlist_id + return int(self._data["sw_runlist_id"][0]) + return self._data["sw_runlist_id"] @sw_runlist_id.setter def sw_runlist_id(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuSchedulerLogEntry instance is read-only") - self._data.sw_runlist_id = val + self._data["sw_runlist_id"] = val @property def target_time_slice(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.target_time_slice[0]) - return self._data.target_time_slice + return int(self._data["target_time_slice"][0]) + return self._data["target_time_slice"] @target_time_slice.setter def target_time_slice(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuSchedulerLogEntry instance is read-only") - self._data.target_time_slice = val + self._data["target_time_slice"] = val @property def cumulative_preemption_time(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.cumulative_preemption_time[0]) - return self._data.cumulative_preemption_time + return int(self._data["cumulative_preemption_time"][0]) + return self._data["cumulative_preemption_time"] @cumulative_preemption_time.setter def cumulative_preemption_time(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuSchedulerLogEntry instance is read-only") - self._data.cumulative_preemption_time = val + self._data["cumulative_preemption_time"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef VgpuSchedulerLogEntry obj if isinstance(key, int): key_ = key size = self._data.size @@ -8776,10 +8845,18 @@ cdef class VgpuSchedulerLogEntry: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return VgpuSchedulerLogEntry.from_data(self._data[key_:key_+1]) + obj = VgpuSchedulerLogEntry.__new__(VgpuSchedulerLogEntry) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == vgpu_scheduler_log_entry_dtype: - return VgpuSchedulerLogEntry.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == vgpu_scheduler_log_entry_dtype: + obj = VgpuSchedulerLogEntry.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -8804,8 +8881,7 @@ cdef class VgpuSchedulerLogEntry: raise ValueError("data array must be 1D") if data.dtype != vgpu_scheduler_log_entry_dtype: raise ValueError("data array must be of dtype vgpu_scheduler_log_entry_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=vgpu_scheduler_log_entry_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -8825,10 +8901,8 @@ cdef class VgpuSchedulerLogEntry: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlVgpuSchedulerLogEntry_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=vgpu_scheduler_log_entry_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=vgpu_scheduler_log_entry_dtype_record) obj._owner = owner - return obj @@ -10235,6 +10309,7 @@ cdef _get_hwbc_entry_dtype_offsets(): }) hwbc_entry_dtype = _get_hwbc_entry_dtype_offsets() +cdef object hwbc_entry_dtype_record = _numpy.dtype((_numpy.record, hwbc_entry_dtype)) cdef class HwbcEntry: """Empty-initialize an array of `nvmlHwbcEntry_t`. @@ -10251,8 +10326,7 @@ cdef class HwbcEntry: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=hwbc_entry_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=hwbc_entry_dtype_record) assert self._data.itemsize == sizeof(nvmlHwbcEntry_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlHwbcEntry_t) }" @@ -10265,17 +10339,17 @@ cdef class HwbcEntry: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -10296,29 +10370,30 @@ cdef class HwbcEntry: def hwbc_id(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.hwbc_id[0]) - return self._data.hwbc_id + return int(self._data["hwbc_id"][0]) + return self._data["hwbc_id"] @hwbc_id.setter def hwbc_id(self, val): if not self._data.flags.writeable: raise ValueError("This HwbcEntry instance is read-only") - self._data.hwbc_id = val + self._data["hwbc_id"] = val @property def firmware_version(self): """~_numpy.int8: (array of length 32).""" - return self._data.firmware_version + return self._data["firmware_version"] @firmware_version.setter def firmware_version(self, val): if not self._data.flags.writeable: raise ValueError("This HwbcEntry instance is read-only") - self._data.firmware_version = val + self._data["firmware_version"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef HwbcEntry obj if isinstance(key, int): key_ = key size = self._data.size @@ -10326,10 +10401,18 @@ cdef class HwbcEntry: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return HwbcEntry.from_data(self._data[key_:key_+1]) + obj = HwbcEntry.__new__(HwbcEntry) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == hwbc_entry_dtype: - return HwbcEntry.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == hwbc_entry_dtype: + obj = HwbcEntry.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -10354,8 +10437,7 @@ cdef class HwbcEntry: raise ValueError("data array must be 1D") if data.dtype != hwbc_entry_dtype: raise ValueError("data array must be of dtype hwbc_entry_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=hwbc_entry_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -10375,10 +10457,8 @@ cdef class HwbcEntry: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlHwbcEntry_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=hwbc_entry_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=hwbc_entry_dtype_record) obj._owner = owner - return obj @@ -10878,6 +10958,7 @@ cdef _get_unit_fan_info_dtype_offsets(): }) unit_fan_info_dtype = _get_unit_fan_info_dtype_offsets() +cdef object unit_fan_info_dtype_record = _numpy.dtype((_numpy.record, unit_fan_info_dtype)) cdef class UnitFanInfo: """Empty-initialize an array of `nvmlUnitFanInfo_t`. @@ -10894,8 +10975,7 @@ cdef class UnitFanInfo: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=unit_fan_info_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=unit_fan_info_dtype_record) assert self._data.itemsize == sizeof(nvmlUnitFanInfo_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlUnitFanInfo_t) }" @@ -10908,17 +10988,17 @@ cdef class UnitFanInfo: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -10939,31 +11019,32 @@ cdef class UnitFanInfo: def speed(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.speed[0]) - return self._data.speed + return int(self._data["speed"][0]) + return self._data["speed"] @speed.setter def speed(self, val): if not self._data.flags.writeable: raise ValueError("This UnitFanInfo instance is read-only") - self._data.speed = val + self._data["speed"] = val @property def state(self): """Union[~_numpy.int32, int]: """ if self._data.size == 1: - return int(self._data.state[0]) - return self._data.state + return int(self._data["state"][0]) + return self._data["state"] @state.setter def state(self, val): if not self._data.flags.writeable: raise ValueError("This UnitFanInfo instance is read-only") - self._data.state = val + self._data["state"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef UnitFanInfo obj if isinstance(key, int): key_ = key size = self._data.size @@ -10971,10 +11052,18 @@ cdef class UnitFanInfo: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return UnitFanInfo.from_data(self._data[key_:key_+1]) + obj = UnitFanInfo.__new__(UnitFanInfo) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == unit_fan_info_dtype: - return UnitFanInfo.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == unit_fan_info_dtype: + obj = UnitFanInfo.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -10999,8 +11088,7 @@ cdef class UnitFanInfo: raise ValueError("data array must be 1D") if data.dtype != unit_fan_info_dtype: raise ValueError("data array must be of dtype unit_fan_info_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=unit_fan_info_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -11020,10 +11108,8 @@ cdef class UnitFanInfo: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlUnitFanInfo_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=unit_fan_info_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=unit_fan_info_dtype_record) obj._owner = owner - return obj @@ -11213,6 +11299,7 @@ cdef _get_system_event_data_v1_dtype_offsets(): }) system_event_data_v1_dtype = _get_system_event_data_v1_dtype_offsets() +cdef object system_event_data_v1_dtype_record = _numpy.dtype((_numpy.record, system_event_data_v1_dtype)) cdef class SystemEventData_v1: """Empty-initialize an array of `nvmlSystemEventData_v1_t`. @@ -11229,8 +11316,7 @@ cdef class SystemEventData_v1: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=system_event_data_v1_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=system_event_data_v1_dtype_record) assert self._data.itemsize == sizeof(nvmlSystemEventData_v1_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlSystemEventData_v1_t) }" @@ -11243,17 +11329,17 @@ cdef class SystemEventData_v1: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -11274,31 +11360,32 @@ cdef class SystemEventData_v1: def event_type(self): """Union[~_numpy.uint64, int]: Information about what specific system event occurred.""" if self._data.size == 1: - return int(self._data.event_type[0]) - return self._data.event_type + return int(self._data["event_type"][0]) + return self._data["event_type"] @event_type.setter def event_type(self, val): if not self._data.flags.writeable: raise ValueError("This SystemEventData_v1 instance is read-only") - self._data.event_type = val + self._data["event_type"] = val @property def gpu_id(self): """Union[~_numpy.uint32, int]: gpuId in PCI format""" if self._data.size == 1: - return int(self._data.gpu_id[0]) - return self._data.gpu_id + return int(self._data["gpu_id"][0]) + return self._data["gpu_id"] @gpu_id.setter def gpu_id(self, val): if not self._data.flags.writeable: raise ValueError("This SystemEventData_v1 instance is read-only") - self._data.gpu_id = val + self._data["gpu_id"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef SystemEventData_v1 obj if isinstance(key, int): key_ = key size = self._data.size @@ -11306,10 +11393,18 @@ cdef class SystemEventData_v1: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return SystemEventData_v1.from_data(self._data[key_:key_+1]) + obj = SystemEventData_v1.__new__(SystemEventData_v1) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == system_event_data_v1_dtype: - return SystemEventData_v1.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == system_event_data_v1_dtype: + obj = SystemEventData_v1.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -11334,8 +11429,7 @@ cdef class SystemEventData_v1: raise ValueError("data array must be 1D") if data.dtype != system_event_data_v1_dtype: raise ValueError("data array must be of dtype system_event_data_v1_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=system_event_data_v1_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -11355,10 +11449,8 @@ cdef class SystemEventData_v1: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlSystemEventData_v1_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=system_event_data_v1_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=system_event_data_v1_dtype_record) obj._owner = owner - return obj @@ -11567,6 +11659,7 @@ cdef _get_encoder_session_info_dtype_offsets(): }) encoder_session_info_dtype = _get_encoder_session_info_dtype_offsets() +cdef object encoder_session_info_dtype_record = _numpy.dtype((_numpy.record, encoder_session_info_dtype)) cdef class EncoderSessionInfo: """Empty-initialize an array of `nvmlEncoderSessionInfo_t`. @@ -11583,8 +11676,7 @@ cdef class EncoderSessionInfo: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=encoder_session_info_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=encoder_session_info_dtype_record) assert self._data.itemsize == sizeof(nvmlEncoderSessionInfo_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlEncoderSessionInfo_t) }" @@ -11597,17 +11689,17 @@ cdef class EncoderSessionInfo: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -11628,109 +11720,110 @@ cdef class EncoderSessionInfo: def session_id(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.session_id[0]) - return self._data.session_id + return int(self._data["session_id"][0]) + return self._data["session_id"] @session_id.setter def session_id(self, val): if not self._data.flags.writeable: raise ValueError("This EncoderSessionInfo instance is read-only") - self._data.session_id = val + self._data["session_id"] = val @property def pid(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.pid[0]) - return self._data.pid + return int(self._data["pid"][0]) + return self._data["pid"] @pid.setter def pid(self, val): if not self._data.flags.writeable: raise ValueError("This EncoderSessionInfo instance is read-only") - self._data.pid = val + self._data["pid"] = val @property def vgpu_instance(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.vgpu_instance[0]) - return self._data.vgpu_instance + return int(self._data["vgpu_instance"][0]) + return self._data["vgpu_instance"] @vgpu_instance.setter def vgpu_instance(self, val): if not self._data.flags.writeable: raise ValueError("This EncoderSessionInfo instance is read-only") - self._data.vgpu_instance = val + self._data["vgpu_instance"] = val @property def codec_type(self): """Union[~_numpy.int32, int]: """ if self._data.size == 1: - return int(self._data.codec_type[0]) - return self._data.codec_type + return int(self._data["codec_type"][0]) + return self._data["codec_type"] @codec_type.setter def codec_type(self, val): if not self._data.flags.writeable: raise ValueError("This EncoderSessionInfo instance is read-only") - self._data.codec_type = val + self._data["codec_type"] = val @property def h_resolution(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.h_resolution[0]) - return self._data.h_resolution + return int(self._data["h_resolution"][0]) + return self._data["h_resolution"] @h_resolution.setter def h_resolution(self, val): if not self._data.flags.writeable: raise ValueError("This EncoderSessionInfo instance is read-only") - self._data.h_resolution = val + self._data["h_resolution"] = val @property def v_resolution(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.v_resolution[0]) - return self._data.v_resolution + return int(self._data["v_resolution"][0]) + return self._data["v_resolution"] @v_resolution.setter def v_resolution(self, val): if not self._data.flags.writeable: raise ValueError("This EncoderSessionInfo instance is read-only") - self._data.v_resolution = val + self._data["v_resolution"] = val @property def average_fps(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.average_fps[0]) - return self._data.average_fps + return int(self._data["average_fps"][0]) + return self._data["average_fps"] @average_fps.setter def average_fps(self, val): if not self._data.flags.writeable: raise ValueError("This EncoderSessionInfo instance is read-only") - self._data.average_fps = val + self._data["average_fps"] = val @property def average_latency(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.average_latency[0]) - return self._data.average_latency + return int(self._data["average_latency"][0]) + return self._data["average_latency"] @average_latency.setter def average_latency(self, val): if not self._data.flags.writeable: raise ValueError("This EncoderSessionInfo instance is read-only") - self._data.average_latency = val + self._data["average_latency"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef EncoderSessionInfo obj if isinstance(key, int): key_ = key size = self._data.size @@ -11738,10 +11831,18 @@ cdef class EncoderSessionInfo: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return EncoderSessionInfo.from_data(self._data[key_:key_+1]) + obj = EncoderSessionInfo.__new__(EncoderSessionInfo) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == encoder_session_info_dtype: - return EncoderSessionInfo.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == encoder_session_info_dtype: + obj = EncoderSessionInfo.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -11766,8 +11867,7 @@ cdef class EncoderSessionInfo: raise ValueError("data array must be 1D") if data.dtype != encoder_session_info_dtype: raise ValueError("data array must be of dtype encoder_session_info_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=encoder_session_info_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -11787,10 +11887,8 @@ cdef class EncoderSessionInfo: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlEncoderSessionInfo_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=encoder_session_info_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=encoder_session_info_dtype_record) obj._owner = owner - return obj @@ -11966,6 +12064,7 @@ cdef _get_fbc_session_info_dtype_offsets(): }) fbc_session_info_dtype = _get_fbc_session_info_dtype_offsets() +cdef object fbc_session_info_dtype_record = _numpy.dtype((_numpy.record, fbc_session_info_dtype)) cdef class FBCSessionInfo: """Empty-initialize an array of `nvmlFBCSessionInfo_t`. @@ -11982,8 +12081,7 @@ cdef class FBCSessionInfo: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=fbc_session_info_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=fbc_session_info_dtype_record) assert self._data.itemsize == sizeof(nvmlFBCSessionInfo_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlFBCSessionInfo_t) }" @@ -11996,17 +12094,17 @@ cdef class FBCSessionInfo: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -12027,161 +12125,162 @@ cdef class FBCSessionInfo: def session_id(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.session_id[0]) - return self._data.session_id + return int(self._data["session_id"][0]) + return self._data["session_id"] @session_id.setter def session_id(self, val): if not self._data.flags.writeable: raise ValueError("This FBCSessionInfo instance is read-only") - self._data.session_id = val + self._data["session_id"] = val @property def pid(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.pid[0]) - return self._data.pid + return int(self._data["pid"][0]) + return self._data["pid"] @pid.setter def pid(self, val): if not self._data.flags.writeable: raise ValueError("This FBCSessionInfo instance is read-only") - self._data.pid = val + self._data["pid"] = val @property def vgpu_instance(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.vgpu_instance[0]) - return self._data.vgpu_instance + return int(self._data["vgpu_instance"][0]) + return self._data["vgpu_instance"] @vgpu_instance.setter def vgpu_instance(self, val): if not self._data.flags.writeable: raise ValueError("This FBCSessionInfo instance is read-only") - self._data.vgpu_instance = val + self._data["vgpu_instance"] = val @property def display_ordinal(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.display_ordinal[0]) - return self._data.display_ordinal + return int(self._data["display_ordinal"][0]) + return self._data["display_ordinal"] @display_ordinal.setter def display_ordinal(self, val): if not self._data.flags.writeable: raise ValueError("This FBCSessionInfo instance is read-only") - self._data.display_ordinal = val + self._data["display_ordinal"] = val @property def session_type(self): """Union[~_numpy.int32, int]: """ if self._data.size == 1: - return int(self._data.session_type[0]) - return self._data.session_type + return int(self._data["session_type"][0]) + return self._data["session_type"] @session_type.setter def session_type(self, val): if not self._data.flags.writeable: raise ValueError("This FBCSessionInfo instance is read-only") - self._data.session_type = val + self._data["session_type"] = val @property def session_flags(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.session_flags[0]) - return self._data.session_flags + return int(self._data["session_flags"][0]) + return self._data["session_flags"] @session_flags.setter def session_flags(self, val): if not self._data.flags.writeable: raise ValueError("This FBCSessionInfo instance is read-only") - self._data.session_flags = val + self._data["session_flags"] = val @property def h_max_resolution(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.h_max_resolution[0]) - return self._data.h_max_resolution + return int(self._data["h_max_resolution"][0]) + return self._data["h_max_resolution"] @h_max_resolution.setter def h_max_resolution(self, val): if not self._data.flags.writeable: raise ValueError("This FBCSessionInfo instance is read-only") - self._data.h_max_resolution = val + self._data["h_max_resolution"] = val @property def v_max_resolution(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.v_max_resolution[0]) - return self._data.v_max_resolution + return int(self._data["v_max_resolution"][0]) + return self._data["v_max_resolution"] @v_max_resolution.setter def v_max_resolution(self, val): if not self._data.flags.writeable: raise ValueError("This FBCSessionInfo instance is read-only") - self._data.v_max_resolution = val + self._data["v_max_resolution"] = val @property def h_resolution(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.h_resolution[0]) - return self._data.h_resolution + return int(self._data["h_resolution"][0]) + return self._data["h_resolution"] @h_resolution.setter def h_resolution(self, val): if not self._data.flags.writeable: raise ValueError("This FBCSessionInfo instance is read-only") - self._data.h_resolution = val + self._data["h_resolution"] = val @property def v_resolution(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.v_resolution[0]) - return self._data.v_resolution + return int(self._data["v_resolution"][0]) + return self._data["v_resolution"] @v_resolution.setter def v_resolution(self, val): if not self._data.flags.writeable: raise ValueError("This FBCSessionInfo instance is read-only") - self._data.v_resolution = val + self._data["v_resolution"] = val @property def average_fps(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.average_fps[0]) - return self._data.average_fps + return int(self._data["average_fps"][0]) + return self._data["average_fps"] @average_fps.setter def average_fps(self, val): if not self._data.flags.writeable: raise ValueError("This FBCSessionInfo instance is read-only") - self._data.average_fps = val + self._data["average_fps"] = val @property def average_latency(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.average_latency[0]) - return self._data.average_latency + return int(self._data["average_latency"][0]) + return self._data["average_latency"] @average_latency.setter def average_latency(self, val): if not self._data.flags.writeable: raise ValueError("This FBCSessionInfo instance is read-only") - self._data.average_latency = val + self._data["average_latency"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef FBCSessionInfo obj if isinstance(key, int): key_ = key size = self._data.size @@ -12189,10 +12288,18 @@ cdef class FBCSessionInfo: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return FBCSessionInfo.from_data(self._data[key_:key_+1]) + obj = FBCSessionInfo.__new__(FBCSessionInfo) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == fbc_session_info_dtype: - return FBCSessionInfo.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == fbc_session_info_dtype: + obj = FBCSessionInfo.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -12217,8 +12324,7 @@ cdef class FBCSessionInfo: raise ValueError("data array must be 1D") if data.dtype != fbc_session_info_dtype: raise ValueError("data array must be of dtype fbc_session_info_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=fbc_session_info_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -12238,10 +12344,8 @@ cdef class FBCSessionInfo: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlFBCSessionInfo_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=fbc_session_info_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=fbc_session_info_dtype_record) obj._owner = owner - return obj @@ -14364,6 +14468,7 @@ cdef _get_gpu_instance_placement_dtype_offsets(): }) gpu_instance_placement_dtype = _get_gpu_instance_placement_dtype_offsets() +cdef object gpu_instance_placement_dtype_record = _numpy.dtype((_numpy.record, gpu_instance_placement_dtype)) cdef class GpuInstancePlacement: """Empty-initialize an array of `nvmlGpuInstancePlacement_t`. @@ -14380,8 +14485,7 @@ cdef class GpuInstancePlacement: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=gpu_instance_placement_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=gpu_instance_placement_dtype_record) assert self._data.itemsize == sizeof(nvmlGpuInstancePlacement_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlGpuInstancePlacement_t) }" @@ -14394,17 +14498,17 @@ cdef class GpuInstancePlacement: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -14425,31 +14529,32 @@ cdef class GpuInstancePlacement: def start(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.start[0]) - return self._data.start + return int(self._data["start"][0]) + return self._data["start"] @start.setter def start(self, val): if not self._data.flags.writeable: raise ValueError("This GpuInstancePlacement instance is read-only") - self._data.start = val + self._data["start"] = val @property def size_(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.size_[0]) - return self._data.size_ + return int(self._data["size_"][0]) + return self._data["size_"] @size_.setter def size_(self, val): if not self._data.flags.writeable: raise ValueError("This GpuInstancePlacement instance is read-only") - self._data.size_ = val + self._data["size_"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef GpuInstancePlacement obj if isinstance(key, int): key_ = key size = self._data.size @@ -14457,10 +14562,18 @@ cdef class GpuInstancePlacement: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return GpuInstancePlacement.from_data(self._data[key_:key_+1]) + obj = GpuInstancePlacement.__new__(GpuInstancePlacement) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == gpu_instance_placement_dtype: - return GpuInstancePlacement.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == gpu_instance_placement_dtype: + obj = GpuInstancePlacement.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -14485,8 +14598,7 @@ cdef class GpuInstancePlacement: raise ValueError("data array must be 1D") if data.dtype != gpu_instance_placement_dtype: raise ValueError("data array must be of dtype gpu_instance_placement_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=gpu_instance_placement_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -14506,10 +14618,8 @@ cdef class GpuInstancePlacement: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlGpuInstancePlacement_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=gpu_instance_placement_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=gpu_instance_placement_dtype_record) obj._owner = owner - return obj @@ -14799,6 +14909,7 @@ cdef _get_compute_instance_placement_dtype_offsets(): }) compute_instance_placement_dtype = _get_compute_instance_placement_dtype_offsets() +cdef object compute_instance_placement_dtype_record = _numpy.dtype((_numpy.record, compute_instance_placement_dtype)) cdef class ComputeInstancePlacement: """Empty-initialize an array of `nvmlComputeInstancePlacement_t`. @@ -14815,8 +14926,7 @@ cdef class ComputeInstancePlacement: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=compute_instance_placement_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=compute_instance_placement_dtype_record) assert self._data.itemsize == sizeof(nvmlComputeInstancePlacement_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlComputeInstancePlacement_t) }" @@ -14829,17 +14939,17 @@ cdef class ComputeInstancePlacement: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -14860,31 +14970,32 @@ cdef class ComputeInstancePlacement: def start(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.start[0]) - return self._data.start + return int(self._data["start"][0]) + return self._data["start"] @start.setter def start(self, val): if not self._data.flags.writeable: raise ValueError("This ComputeInstancePlacement instance is read-only") - self._data.start = val + self._data["start"] = val @property def size_(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.size_[0]) - return self._data.size_ + return int(self._data["size_"][0]) + return self._data["size_"] @size_.setter def size_(self, val): if not self._data.flags.writeable: raise ValueError("This ComputeInstancePlacement instance is read-only") - self._data.size_ = val + self._data["size_"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef ComputeInstancePlacement obj if isinstance(key, int): key_ = key size = self._data.size @@ -14892,10 +15003,18 @@ cdef class ComputeInstancePlacement: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return ComputeInstancePlacement.from_data(self._data[key_:key_+1]) + obj = ComputeInstancePlacement.__new__(ComputeInstancePlacement) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == compute_instance_placement_dtype: - return ComputeInstancePlacement.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == compute_instance_placement_dtype: + obj = ComputeInstancePlacement.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -14920,8 +15039,7 @@ cdef class ComputeInstancePlacement: raise ValueError("data array must be 1D") if data.dtype != compute_instance_placement_dtype: raise ValueError("data array must be of dtype compute_instance_placement_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=compute_instance_placement_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -14941,10 +15059,8 @@ cdef class ComputeInstancePlacement: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlComputeInstancePlacement_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=compute_instance_placement_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=compute_instance_placement_dtype_record) obj._owner = owner - return obj @@ -15911,6 +16027,7 @@ cdef _get_ecc_sram_unique_uncorrected_error_entry_v1_dtype_offsets(): }) ecc_sram_unique_uncorrected_error_entry_v1_dtype = _get_ecc_sram_unique_uncorrected_error_entry_v1_dtype_offsets() +cdef object ecc_sram_unique_uncorrected_error_entry_v1_dtype_record = _numpy.dtype((_numpy.record, ecc_sram_unique_uncorrected_error_entry_v1_dtype)) cdef class EccSramUniqueUncorrectedErrorEntry_v1: """Empty-initialize an array of `nvmlEccSramUniqueUncorrectedErrorEntry_v1_t`. @@ -15927,8 +16044,7 @@ cdef class EccSramUniqueUncorrectedErrorEntry_v1: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=ecc_sram_unique_uncorrected_error_entry_v1_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=ecc_sram_unique_uncorrected_error_entry_v1_dtype_record) assert self._data.itemsize == sizeof(nvmlEccSramUniqueUncorrectedErrorEntry_v1_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlEccSramUniqueUncorrectedErrorEntry_v1_t) }" @@ -15941,17 +16057,17 @@ cdef class EccSramUniqueUncorrectedErrorEntry_v1: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -15972,96 +16088,97 @@ cdef class EccSramUniqueUncorrectedErrorEntry_v1: def unit(self): """Union[~_numpy.uint32, int]: the SRAM unit index""" if self._data.size == 1: - return int(self._data.unit[0]) - return self._data.unit + return int(self._data["unit"][0]) + return self._data["unit"] @unit.setter def unit(self, val): if not self._data.flags.writeable: raise ValueError("This EccSramUniqueUncorrectedErrorEntry_v1 instance is read-only") - self._data.unit = val + self._data["unit"] = val @property def location(self): """Union[~_numpy.uint32, int]: the error location within the SRAM unit""" if self._data.size == 1: - return int(self._data.location[0]) - return self._data.location + return int(self._data["location"][0]) + return self._data["location"] @location.setter def location(self, val): if not self._data.flags.writeable: raise ValueError("This EccSramUniqueUncorrectedErrorEntry_v1 instance is read-only") - self._data.location = val + self._data["location"] = val @property def sublocation(self): """Union[~_numpy.uint32, int]: the error sublocation within the SRAM unit""" if self._data.size == 1: - return int(self._data.sublocation[0]) - return self._data.sublocation + return int(self._data["sublocation"][0]) + return self._data["sublocation"] @sublocation.setter def sublocation(self, val): if not self._data.flags.writeable: raise ValueError("This EccSramUniqueUncorrectedErrorEntry_v1 instance is read-only") - self._data.sublocation = val + self._data["sublocation"] = val @property def extlocation(self): """Union[~_numpy.uint32, int]: the error extlocation within the SRAM unit""" if self._data.size == 1: - return int(self._data.extlocation[0]) - return self._data.extlocation + return int(self._data["extlocation"][0]) + return self._data["extlocation"] @extlocation.setter def extlocation(self, val): if not self._data.flags.writeable: raise ValueError("This EccSramUniqueUncorrectedErrorEntry_v1 instance is read-only") - self._data.extlocation = val + self._data["extlocation"] = val @property def address(self): """Union[~_numpy.uint32, int]: the error address within the SRAM unit""" if self._data.size == 1: - return int(self._data.address[0]) - return self._data.address + return int(self._data["address"][0]) + return self._data["address"] @address.setter def address(self, val): if not self._data.flags.writeable: raise ValueError("This EccSramUniqueUncorrectedErrorEntry_v1 instance is read-only") - self._data.address = val + self._data["address"] = val @property def is_parity(self): """Union[~_numpy.uint32, int]: if the SRAM error is parity or not""" if self._data.size == 1: - return int(self._data.is_parity[0]) - return self._data.is_parity + return int(self._data["is_parity"][0]) + return self._data["is_parity"] @is_parity.setter def is_parity(self, val): if not self._data.flags.writeable: raise ValueError("This EccSramUniqueUncorrectedErrorEntry_v1 instance is read-only") - self._data.is_parity = val + self._data["is_parity"] = val @property def count(self): """Union[~_numpy.uint32, int]: the error count at the same SRAM address""" if self._data.size == 1: - return int(self._data.count[0]) - return self._data.count + return int(self._data["count"][0]) + return self._data["count"] @count.setter def count(self, val): if not self._data.flags.writeable: raise ValueError("This EccSramUniqueUncorrectedErrorEntry_v1 instance is read-only") - self._data.count = val + self._data["count"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef EccSramUniqueUncorrectedErrorEntry_v1 obj if isinstance(key, int): key_ = key size = self._data.size @@ -16069,10 +16186,18 @@ cdef class EccSramUniqueUncorrectedErrorEntry_v1: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return EccSramUniqueUncorrectedErrorEntry_v1.from_data(self._data[key_:key_+1]) + obj = EccSramUniqueUncorrectedErrorEntry_v1.__new__(EccSramUniqueUncorrectedErrorEntry_v1) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == ecc_sram_unique_uncorrected_error_entry_v1_dtype: - return EccSramUniqueUncorrectedErrorEntry_v1.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == ecc_sram_unique_uncorrected_error_entry_v1_dtype: + obj = EccSramUniqueUncorrectedErrorEntry_v1.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -16097,8 +16222,7 @@ cdef class EccSramUniqueUncorrectedErrorEntry_v1: raise ValueError("data array must be 1D") if data.dtype != ecc_sram_unique_uncorrected_error_entry_v1_dtype: raise ValueError("data array must be of dtype ecc_sram_unique_uncorrected_error_entry_v1_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=ecc_sram_unique_uncorrected_error_entry_v1_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -16118,10 +16242,8 @@ cdef class EccSramUniqueUncorrectedErrorEntry_v1: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlEccSramUniqueUncorrectedErrorEntry_v1_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=ecc_sram_unique_uncorrected_error_entry_v1_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=ecc_sram_unique_uncorrected_error_entry_v1_dtype_record) obj._owner = owner - return obj @@ -16480,6 +16602,7 @@ cdef _get_nvlink_firmware_version_dtype_offsets(): }) nvlink_firmware_version_dtype = _get_nvlink_firmware_version_dtype_offsets() +cdef object nvlink_firmware_version_dtype_record = _numpy.dtype((_numpy.record, nvlink_firmware_version_dtype)) cdef class NvlinkFirmwareVersion: """Empty-initialize an array of `nvmlNvlinkFirmwareVersion_t`. @@ -16496,8 +16619,7 @@ cdef class NvlinkFirmwareVersion: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=nvlink_firmware_version_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=nvlink_firmware_version_dtype_record) assert self._data.itemsize == sizeof(nvmlNvlinkFirmwareVersion_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlNvlinkFirmwareVersion_t) }" @@ -16510,17 +16632,17 @@ cdef class NvlinkFirmwareVersion: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -16541,57 +16663,58 @@ cdef class NvlinkFirmwareVersion: def ucode_type(self): """Union[~_numpy.uint8, int]: """ if self._data.size == 1: - return int(self._data.ucode_type[0]) - return self._data.ucode_type + return int(self._data["ucode_type"][0]) + return self._data["ucode_type"] @ucode_type.setter def ucode_type(self, val): if not self._data.flags.writeable: raise ValueError("This NvlinkFirmwareVersion instance is read-only") - self._data.ucode_type = val + self._data["ucode_type"] = val @property def major(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.major[0]) - return self._data.major + return int(self._data["major"][0]) + return self._data["major"] @major.setter def major(self, val): if not self._data.flags.writeable: raise ValueError("This NvlinkFirmwareVersion instance is read-only") - self._data.major = val + self._data["major"] = val @property def minor(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.minor[0]) - return self._data.minor + return int(self._data["minor"][0]) + return self._data["minor"] @minor.setter def minor(self, val): if not self._data.flags.writeable: raise ValueError("This NvlinkFirmwareVersion instance is read-only") - self._data.minor = val + self._data["minor"] = val @property def sub_minor(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.sub_minor[0]) - return self._data.sub_minor + return int(self._data["sub_minor"][0]) + return self._data["sub_minor"] @sub_minor.setter def sub_minor(self, val): if not self._data.flags.writeable: raise ValueError("This NvlinkFirmwareVersion instance is read-only") - self._data.sub_minor = val + self._data["sub_minor"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef NvlinkFirmwareVersion obj if isinstance(key, int): key_ = key size = self._data.size @@ -16599,10 +16722,18 @@ cdef class NvlinkFirmwareVersion: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return NvlinkFirmwareVersion.from_data(self._data[key_:key_+1]) + obj = NvlinkFirmwareVersion.__new__(NvlinkFirmwareVersion) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == nvlink_firmware_version_dtype: - return NvlinkFirmwareVersion.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == nvlink_firmware_version_dtype: + obj = NvlinkFirmwareVersion.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -16627,8 +16758,7 @@ cdef class NvlinkFirmwareVersion: raise ValueError("data array must be 1D") if data.dtype != nvlink_firmware_version_dtype: raise ValueError("data array must be of dtype nvlink_firmware_version_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=nvlink_firmware_version_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -16648,10 +16778,8 @@ cdef class NvlinkFirmwareVersion: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlNvlinkFirmwareVersion_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=nvlink_firmware_version_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=nvlink_firmware_version_dtype_record) obj._owner = owner - return obj @@ -16971,6 +17099,7 @@ cdef _get_vgpu_scheduler_log_entry_v2_dtype_offsets(): }) vgpu_scheduler_log_entry_v2_dtype = _get_vgpu_scheduler_log_entry_v2_dtype_offsets() +cdef object vgpu_scheduler_log_entry_v2_dtype_record = _numpy.dtype((_numpy.record, vgpu_scheduler_log_entry_v2_dtype)) cdef class VgpuSchedulerLogEntry_v2: """Empty-initialize an array of `nvmlVgpuSchedulerLogEntry_v2_t`. @@ -16987,8 +17116,7 @@ cdef class VgpuSchedulerLogEntry_v2: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=vgpu_scheduler_log_entry_v2_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=vgpu_scheduler_log_entry_v2_dtype_record) assert self._data.itemsize == sizeof(nvmlVgpuSchedulerLogEntry_v2_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlVgpuSchedulerLogEntry_v2_t) }" @@ -17001,17 +17129,17 @@ cdef class VgpuSchedulerLogEntry_v2: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -17032,96 +17160,97 @@ cdef class VgpuSchedulerLogEntry_v2: def timestamp(self): """Union[~_numpy.uint64, int]: OUT: Timestamp in ns when this software runlist was preeempted.""" if self._data.size == 1: - return int(self._data.timestamp[0]) - return self._data.timestamp + return int(self._data["timestamp"][0]) + return self._data["timestamp"] @timestamp.setter def timestamp(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuSchedulerLogEntry_v2 instance is read-only") - self._data.timestamp = val + self._data["timestamp"] = val @property def time_run_total(self): """Union[~_numpy.uint64, int]: OUT: Total time in ns this software runlist has run.""" if self._data.size == 1: - return int(self._data.time_run_total[0]) - return self._data.time_run_total + return int(self._data["time_run_total"][0]) + return self._data["time_run_total"] @time_run_total.setter def time_run_total(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuSchedulerLogEntry_v2 instance is read-only") - self._data.time_run_total = val + self._data["time_run_total"] = val @property def time_run(self): """Union[~_numpy.uint64, int]: OUT: Time in ns this software runlist ran before preemption.""" if self._data.size == 1: - return int(self._data.time_run[0]) - return self._data.time_run + return int(self._data["time_run"][0]) + return self._data["time_run"] @time_run.setter def time_run(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuSchedulerLogEntry_v2 instance is read-only") - self._data.time_run = val + self._data["time_run"] = val @property def sw_runlist_id(self): """Union[~_numpy.uint32, int]: OUT: Software runlist Id.""" if self._data.size == 1: - return int(self._data.sw_runlist_id[0]) - return self._data.sw_runlist_id + return int(self._data["sw_runlist_id"][0]) + return self._data["sw_runlist_id"] @sw_runlist_id.setter def sw_runlist_id(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuSchedulerLogEntry_v2 instance is read-only") - self._data.sw_runlist_id = val + self._data["sw_runlist_id"] = val @property def target_time_slice(self): """Union[~_numpy.uint64, int]: OUT: The actual timeslice after deduction.""" if self._data.size == 1: - return int(self._data.target_time_slice[0]) - return self._data.target_time_slice + return int(self._data["target_time_slice"][0]) + return self._data["target_time_slice"] @target_time_slice.setter def target_time_slice(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuSchedulerLogEntry_v2 instance is read-only") - self._data.target_time_slice = val + self._data["target_time_slice"] = val @property def cumulative_preemption_time(self): """Union[~_numpy.uint64, int]: OUT: Preemption time in ns for this SW runlist.""" if self._data.size == 1: - return int(self._data.cumulative_preemption_time[0]) - return self._data.cumulative_preemption_time + return int(self._data["cumulative_preemption_time"][0]) + return self._data["cumulative_preemption_time"] @cumulative_preemption_time.setter def cumulative_preemption_time(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuSchedulerLogEntry_v2 instance is read-only") - self._data.cumulative_preemption_time = val + self._data["cumulative_preemption_time"] = val @property def weight(self): """Union[~_numpy.uint32, int]: OUT: Current weight of this SW runlist.""" if self._data.size == 1: - return int(self._data.weight[0]) - return self._data.weight + return int(self._data["weight"][0]) + return self._data["weight"] @weight.setter def weight(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuSchedulerLogEntry_v2 instance is read-only") - self._data.weight = val + self._data["weight"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef VgpuSchedulerLogEntry_v2 obj if isinstance(key, int): key_ = key size = self._data.size @@ -17129,10 +17258,18 @@ cdef class VgpuSchedulerLogEntry_v2: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return VgpuSchedulerLogEntry_v2.from_data(self._data[key_:key_+1]) + obj = VgpuSchedulerLogEntry_v2.__new__(VgpuSchedulerLogEntry_v2) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == vgpu_scheduler_log_entry_v2_dtype: - return VgpuSchedulerLogEntry_v2.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == vgpu_scheduler_log_entry_v2_dtype: + obj = VgpuSchedulerLogEntry_v2.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -17157,8 +17294,7 @@ cdef class VgpuSchedulerLogEntry_v2: raise ValueError("data array must be 1D") if data.dtype != vgpu_scheduler_log_entry_v2_dtype: raise ValueError("data array must be of dtype vgpu_scheduler_log_entry_v2_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=vgpu_scheduler_log_entry_v2_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -17178,10 +17314,8 @@ cdef class VgpuSchedulerLogEntry_v2: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlVgpuSchedulerLogEntry_v2_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=vgpu_scheduler_log_entry_v2_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=vgpu_scheduler_log_entry_v2_dtype_record) obj._owner = owner - return obj @@ -18394,6 +18528,7 @@ cdef _get_pmgr_pwr_tuple_dtype_offsets(): }) pmgr_pwr_tuple_dtype = _get_pmgr_pwr_tuple_dtype_offsets() +cdef object pmgr_pwr_tuple_dtype_record = _numpy.dtype((_numpy.record, pmgr_pwr_tuple_dtype)) cdef class PmgrPwrTuple: """Empty-initialize an array of `nvmlPmgrPwrTuple_t`. @@ -18410,8 +18545,7 @@ cdef class PmgrPwrTuple: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=pmgr_pwr_tuple_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=pmgr_pwr_tuple_dtype_record) assert self._data.itemsize == sizeof(nvmlPmgrPwrTuple_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlPmgrPwrTuple_t) }" @@ -18424,17 +18558,17 @@ cdef class PmgrPwrTuple: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -18455,18 +18589,19 @@ cdef class PmgrPwrTuple: def pwrm_w(self): """Union[~_numpy.uint32, int]: Power consumption in milliwatts.""" if self._data.size == 1: - return int(self._data.pwrm_w[0]) - return self._data.pwrm_w + return int(self._data["pwrm_w"][0]) + return self._data["pwrm_w"] @pwrm_w.setter def pwrm_w(self, val): if not self._data.flags.writeable: raise ValueError("This PmgrPwrTuple instance is read-only") - self._data.pwrm_w = val + self._data["pwrm_w"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef PmgrPwrTuple obj if isinstance(key, int): key_ = key size = self._data.size @@ -18474,10 +18609,18 @@ cdef class PmgrPwrTuple: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return PmgrPwrTuple.from_data(self._data[key_:key_+1]) + obj = PmgrPwrTuple.__new__(PmgrPwrTuple) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == pmgr_pwr_tuple_dtype: - return PmgrPwrTuple.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == pmgr_pwr_tuple_dtype: + obj = PmgrPwrTuple.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -18502,8 +18645,7 @@ cdef class PmgrPwrTuple: raise ValueError("data array must be 1D") if data.dtype != pmgr_pwr_tuple_dtype: raise ValueError("data array must be of dtype pmgr_pwr_tuple_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=pmgr_pwr_tuple_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -18523,10 +18665,8 @@ cdef class PmgrPwrTuple: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlPmgrPwrTuple_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=pmgr_pwr_tuple_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=pmgr_pwr_tuple_dtype_record) obj._owner = owner - return obj @@ -18543,6 +18683,7 @@ cdef _get_rail_metrics_dtype_offsets(): }) rail_metrics_dtype = _get_rail_metrics_dtype_offsets() +cdef object rail_metrics_dtype_record = _numpy.dtype((_numpy.record, rail_metrics_dtype)) cdef class RailMetrics: """Empty-initialize an array of `nvmlRailMetrics_t`. @@ -18559,8 +18700,7 @@ cdef class RailMetrics: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=rail_metrics_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=rail_metrics_dtype_record) assert self._data.itemsize == sizeof(nvmlRailMetrics_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlRailMetrics_t) }" @@ -18573,17 +18713,17 @@ cdef class RailMetrics: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -18604,31 +18744,32 @@ cdef class RailMetrics: def freqk_hz(self): """Union[~_numpy.uint32, int]: Frequency in kilohertz.""" if self._data.size == 1: - return int(self._data.freqk_hz[0]) - return self._data.freqk_hz + return int(self._data["freqk_hz"][0]) + return self._data["freqk_hz"] @freqk_hz.setter def freqk_hz(self, val): if not self._data.flags.writeable: raise ValueError("This RailMetrics instance is read-only") - self._data.freqk_hz = val + self._data["freqk_hz"] = val @property def util_pct(self): """Union[~_numpy.uint64, int]: Utilization percentage (fixed-point).""" if self._data.size == 1: - return int(self._data.util_pct[0]) - return self._data.util_pct + return int(self._data["util_pct"][0]) + return self._data["util_pct"] @util_pct.setter def util_pct(self, val): if not self._data.flags.writeable: raise ValueError("This RailMetrics instance is read-only") - self._data.util_pct = val + self._data["util_pct"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef RailMetrics obj if isinstance(key, int): key_ = key size = self._data.size @@ -18636,10 +18777,18 @@ cdef class RailMetrics: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return RailMetrics.from_data(self._data[key_:key_+1]) + obj = RailMetrics.__new__(RailMetrics) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == rail_metrics_dtype: - return RailMetrics.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == rail_metrics_dtype: + obj = RailMetrics.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -18664,8 +18813,7 @@ cdef class RailMetrics: raise ValueError("data array must be 1D") if data.dtype != rail_metrics_dtype: raise ValueError("data array must be of dtype rail_metrics_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=rail_metrics_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -18685,10 +18833,8 @@ cdef class RailMetrics: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlRailMetrics_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=rail_metrics_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=rail_metrics_dtype_record) obj._owner = owner - return obj @@ -18704,6 +18850,7 @@ cdef _get_pwr_model_metrics_dlppm1x_perf_dtype_offsets(): }) pwr_model_metrics_dlppm1x_perf_dtype = _get_pwr_model_metrics_dlppm1x_perf_dtype_offsets() +cdef object pwr_model_metrics_dlppm1x_perf_dtype_record = _numpy.dtype((_numpy.record, pwr_model_metrics_dlppm1x_perf_dtype)) cdef class PwrModelMetricsDlppm1xPerf: """Empty-initialize an array of `nvmlPwrModelMetricsDlppm1xPerf_t`. @@ -18720,8 +18867,7 @@ cdef class PwrModelMetricsDlppm1xPerf: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=pwr_model_metrics_dlppm1x_perf_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=pwr_model_metrics_dlppm1x_perf_dtype_record) assert self._data.itemsize == sizeof(nvmlPwrModelMetricsDlppm1xPerf_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlPwrModelMetricsDlppm1xPerf_t) }" @@ -18734,17 +18880,17 @@ cdef class PwrModelMetricsDlppm1xPerf: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -18765,18 +18911,19 @@ cdef class PwrModelMetricsDlppm1xPerf: def perfms(self): """Union[~_numpy.uint32, int]: Performance metric in milliseconds.""" if self._data.size == 1: - return int(self._data.perfms[0]) - return self._data.perfms + return int(self._data["perfms"][0]) + return self._data["perfms"] @perfms.setter def perfms(self, val): if not self._data.flags.writeable: raise ValueError("This PwrModelMetricsDlppm1xPerf instance is read-only") - self._data.perfms = val + self._data["perfms"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef PwrModelMetricsDlppm1xPerf obj if isinstance(key, int): key_ = key size = self._data.size @@ -18784,10 +18931,18 @@ cdef class PwrModelMetricsDlppm1xPerf: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return PwrModelMetricsDlppm1xPerf.from_data(self._data[key_:key_+1]) + obj = PwrModelMetricsDlppm1xPerf.__new__(PwrModelMetricsDlppm1xPerf) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == pwr_model_metrics_dlppm1x_perf_dtype: - return PwrModelMetricsDlppm1xPerf.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == pwr_model_metrics_dlppm1x_perf_dtype: + obj = PwrModelMetricsDlppm1xPerf.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -18812,8 +18967,7 @@ cdef class PwrModelMetricsDlppm1xPerf: raise ValueError("data array must be 1D") if data.dtype != pwr_model_metrics_dlppm1x_perf_dtype: raise ValueError("data array must be of dtype pwr_model_metrics_dlppm1x_perf_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=pwr_model_metrics_dlppm1x_perf_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -18833,10 +18987,8 @@ cdef class PwrModelMetricsDlppm1xPerf: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlPwrModelMetricsDlppm1xPerf_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=pwr_model_metrics_dlppm1x_perf_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=pwr_model_metrics_dlppm1x_perf_dtype_record) obj._owner = owner - return obj @@ -18853,6 +19005,7 @@ cdef _get_pwr_model_metrics_sample_pfpp1x_dtype_offsets(): }) pwr_model_metrics_sample_pfpp1x_dtype = _get_pwr_model_metrics_sample_pfpp1x_dtype_offsets() +cdef object pwr_model_metrics_sample_pfpp1x_dtype_record = _numpy.dtype((_numpy.record, pwr_model_metrics_sample_pfpp1x_dtype)) cdef class PwrModelMetricsSamplePfpp1x: """Empty-initialize an array of `nvmlPwrModelMetricsSamplePfpp1x_t`. @@ -18869,8 +19022,7 @@ cdef class PwrModelMetricsSamplePfpp1x: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=pwr_model_metrics_sample_pfpp1x_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=pwr_model_metrics_sample_pfpp1x_dtype_record) assert self._data.itemsize == sizeof(nvmlPwrModelMetricsSamplePfpp1x_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlPwrModelMetricsSamplePfpp1x_t) }" @@ -18883,17 +19035,17 @@ cdef class PwrModelMetricsSamplePfpp1x: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -18913,30 +19065,31 @@ cdef class PwrModelMetricsSamplePfpp1x: @property def freqk_hz(self): """~_numpy.uint32: (array of length 16).Array of input frequencies in kilohertz for each domain.""" - return self._data.freqk_hz + return self._data["freqk_hz"] @freqk_hz.setter def freqk_hz(self, val): if not self._data.flags.writeable: raise ValueError("This PwrModelMetricsSamplePfpp1x instance is read-only") - self._data.freqk_hz = val + self._data["freqk_hz"] = val @property def est_tgp_pwrm_w(self): """Union[~_numpy.uint32, int]: Estimated Total Graphics Power in milliwatts.""" if self._data.size == 1: - return int(self._data.est_tgp_pwrm_w[0]) - return self._data.est_tgp_pwrm_w + return int(self._data["est_tgp_pwrm_w"][0]) + return self._data["est_tgp_pwrm_w"] @est_tgp_pwrm_w.setter def est_tgp_pwrm_w(self, val): if not self._data.flags.writeable: raise ValueError("This PwrModelMetricsSamplePfpp1x instance is read-only") - self._data.est_tgp_pwrm_w = val + self._data["est_tgp_pwrm_w"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef PwrModelMetricsSamplePfpp1x obj if isinstance(key, int): key_ = key size = self._data.size @@ -18944,10 +19097,18 @@ cdef class PwrModelMetricsSamplePfpp1x: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return PwrModelMetricsSamplePfpp1x.from_data(self._data[key_:key_+1]) + obj = PwrModelMetricsSamplePfpp1x.__new__(PwrModelMetricsSamplePfpp1x) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == pwr_model_metrics_sample_pfpp1x_dtype: - return PwrModelMetricsSamplePfpp1x.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == pwr_model_metrics_sample_pfpp1x_dtype: + obj = PwrModelMetricsSamplePfpp1x.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -18972,8 +19133,7 @@ cdef class PwrModelMetricsSamplePfpp1x: raise ValueError("data array must be 1D") if data.dtype != pwr_model_metrics_sample_pfpp1x_dtype: raise ValueError("data array must be of dtype pwr_model_metrics_sample_pfpp1x_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=pwr_model_metrics_sample_pfpp1x_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -18993,10 +19153,8 @@ cdef class PwrModelMetricsSamplePfpp1x: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlPwrModelMetricsSamplePfpp1x_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=pwr_model_metrics_sample_pfpp1x_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=pwr_model_metrics_sample_pfpp1x_dtype_record) obj._owner = owner - return obj @@ -19013,6 +19171,7 @@ cdef _get_pwr_model_operating_point_pfpp1x_dtype_offsets(): }) pwr_model_operating_point_pfpp1x_dtype = _get_pwr_model_operating_point_pfpp1x_dtype_offsets() +cdef object pwr_model_operating_point_pfpp1x_dtype_record = _numpy.dtype((_numpy.record, pwr_model_operating_point_pfpp1x_dtype)) cdef class PwrModelOperatingPointPfpp1x: """Empty-initialize an array of `nvmlPwrModelOperatingPointPfpp1x_t`. @@ -19029,8 +19188,7 @@ cdef class PwrModelOperatingPointPfpp1x: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=pwr_model_operating_point_pfpp1x_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=pwr_model_operating_point_pfpp1x_dtype_record) assert self._data.itemsize == sizeof(nvmlPwrModelOperatingPointPfpp1x_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlPwrModelOperatingPointPfpp1x_t) }" @@ -19043,17 +19201,17 @@ cdef class PwrModelOperatingPointPfpp1x: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -19074,31 +19232,32 @@ cdef class PwrModelOperatingPointPfpp1x: def freqk_hz(self): """Union[~_numpy.uint32, int]: Operating frequency in kilohertz.""" if self._data.size == 1: - return int(self._data.freqk_hz[0]) - return self._data.freqk_hz + return int(self._data["freqk_hz"][0]) + return self._data["freqk_hz"] @freqk_hz.setter def freqk_hz(self, val): if not self._data.flags.writeable: raise ValueError("This PwrModelOperatingPointPfpp1x instance is read-only") - self._data.freqk_hz = val + self._data["freqk_hz"] = val @property def pwrm_w(self): """Union[~_numpy.uint32, int]: Power consumption at this frequency in milliwatts.""" if self._data.size == 1: - return int(self._data.pwrm_w[0]) - return self._data.pwrm_w + return int(self._data["pwrm_w"][0]) + return self._data["pwrm_w"] @pwrm_w.setter def pwrm_w(self, val): if not self._data.flags.writeable: raise ValueError("This PwrModelOperatingPointPfpp1x instance is read-only") - self._data.pwrm_w = val + self._data["pwrm_w"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef PwrModelOperatingPointPfpp1x obj if isinstance(key, int): key_ = key size = self._data.size @@ -19106,10 +19265,18 @@ cdef class PwrModelOperatingPointPfpp1x: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return PwrModelOperatingPointPfpp1x.from_data(self._data[key_:key_+1]) + obj = PwrModelOperatingPointPfpp1x.__new__(PwrModelOperatingPointPfpp1x) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == pwr_model_operating_point_pfpp1x_dtype: - return PwrModelOperatingPointPfpp1x.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == pwr_model_operating_point_pfpp1x_dtype: + obj = PwrModelOperatingPointPfpp1x.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -19134,8 +19301,7 @@ cdef class PwrModelOperatingPointPfpp1x: raise ValueError("data array must be 1D") if data.dtype != pwr_model_operating_point_pfpp1x_dtype: raise ValueError("data array must be of dtype pwr_model_operating_point_pfpp1x_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=pwr_model_operating_point_pfpp1x_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -19155,10 +19321,8 @@ cdef class PwrModelOperatingPointPfpp1x: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlPwrModelOperatingPointPfpp1x_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=pwr_model_operating_point_pfpp1x_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=pwr_model_operating_point_pfpp1x_dtype_record) obj._owner = owner - return obj @@ -20658,6 +20822,7 @@ cdef _get_nvlink_telemetry_sample_v1_dtype_offsets(): }) nvlink_telemetry_sample_v1_dtype = _get_nvlink_telemetry_sample_v1_dtype_offsets() +cdef object nvlink_telemetry_sample_v1_dtype_record = _numpy.dtype((_numpy.record, nvlink_telemetry_sample_v1_dtype)) cdef class NvlinkTelemetrySample_v1: """Empty-initialize an array of `nvmlNvlinkTelemetrySample_v1_t`. @@ -20674,8 +20839,7 @@ cdef class NvlinkTelemetrySample_v1: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=nvlink_telemetry_sample_v1_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=nvlink_telemetry_sample_v1_dtype_record) assert self._data.itemsize == sizeof(nvmlNvlinkTelemetrySample_v1_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlNvlinkTelemetrySample_v1_t) }" @@ -20688,17 +20852,17 @@ cdef class NvlinkTelemetrySample_v1: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -20719,70 +20883,71 @@ cdef class NvlinkTelemetrySample_v1: def link_id(self): """Union[~_numpy.uint32, int]: [in] LinkId""" if self._data.size == 1: - return int(self._data.link_id[0]) - return self._data.link_id + return int(self._data["link_id"][0]) + return self._data["link_id"] @link_id.setter def link_id(self, val): if not self._data.flags.writeable: raise ValueError("This NvlinkTelemetrySample_v1 instance is read-only") - self._data.link_id = val + self._data["link_id"] = val @property def sample_type(self): """Union[~_numpy.uint32, int]: [in] Type of telemetry to sample, specified by `nvmlNvlinkTelemetrySampleType_t`""" if self._data.size == 1: - return int(self._data.sample_type[0]) - return self._data.sample_type + return int(self._data["sample_type"][0]) + return self._data["sample_type"] @sample_type.setter def sample_type(self, val): if not self._data.flags.writeable: raise ValueError("This NvlinkTelemetrySample_v1 instance is read-only") - self._data.sample_type = val + self._data["sample_type"] = val @property def sample_count(self): """Union[~_numpy.uint32, int]: [in,out]: Number of samples users need to allocate. If set to 0, will return max supported count of samples without touching the ``samples`` pointer.""" if self._data.size == 1: - return int(self._data.sample_count[0]) - return self._data.sample_count + return int(self._data["sample_count"][0]) + return self._data["sample_count"] @sample_count.setter def sample_count(self, val): if not self._data.flags.writeable: raise ValueError("This NvlinkTelemetrySample_v1 instance is read-only") - self._data.sample_count = val + self._data["sample_count"] = val @property def samples(self): """Union[~_numpy.intp, int]: [in,out]: Array of samples allocated by the user. Can be set to NULL when getting count""" if self._data.size == 1: - return int(self._data.samples[0]) - return self._data.samples + return int(self._data["samples"][0]) + return self._data["samples"] @samples.setter def samples(self, val): if not self._data.flags.writeable: raise ValueError("This NvlinkTelemetrySample_v1 instance is read-only") - self._data.samples = val + self._data["samples"] = val @property def nvml_return(self): """Union[~_numpy.int32, int]: [out]: Return code for retrieving this sample. This must be checked by the client before looking at any output values, as they are invalid if ``nvmlReturn != NVML_SUCCESS``.""" if self._data.size == 1: - return int(self._data.nvml_return[0]) - return self._data.nvml_return + return int(self._data["nvml_return"][0]) + return self._data["nvml_return"] @nvml_return.setter def nvml_return(self, val): if not self._data.flags.writeable: raise ValueError("This NvlinkTelemetrySample_v1 instance is read-only") - self._data.nvml_return = val + self._data["nvml_return"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef NvlinkTelemetrySample_v1 obj if isinstance(key, int): key_ = key size = self._data.size @@ -20790,10 +20955,18 @@ cdef class NvlinkTelemetrySample_v1: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return NvlinkTelemetrySample_v1.from_data(self._data[key_:key_+1]) + obj = NvlinkTelemetrySample_v1.__new__(NvlinkTelemetrySample_v1) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == nvlink_telemetry_sample_v1_dtype: - return NvlinkTelemetrySample_v1.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == nvlink_telemetry_sample_v1_dtype: + obj = NvlinkTelemetrySample_v1.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -20818,8 +20991,7 @@ cdef class NvlinkTelemetrySample_v1: raise ValueError("data array must be 1D") if data.dtype != nvlink_telemetry_sample_v1_dtype: raise ValueError("data array must be of dtype nvlink_telemetry_sample_v1_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=nvlink_telemetry_sample_v1_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -20839,10 +21011,8 @@ cdef class NvlinkTelemetrySample_v1: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlNvlinkTelemetrySample_v1_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=nvlink_telemetry_sample_v1_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=nvlink_telemetry_sample_v1_dtype_record) obj._owner = owner - return obj @@ -21454,6 +21624,7 @@ cdef _get_sample_dtype_offsets(): }) sample_dtype = _get_sample_dtype_offsets() +cdef object sample_dtype_record = _numpy.dtype((_numpy.record, sample_dtype)) cdef class Sample: """Empty-initialize an array of `nvmlSample_t`. @@ -21470,8 +21641,7 @@ cdef class Sample: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=sample_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=sample_dtype_record) assert self._data.itemsize == sizeof(nvmlSample_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlSample_t) }" @@ -21484,17 +21654,17 @@ cdef class Sample: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -21515,29 +21685,30 @@ cdef class Sample: def time_stamp(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.time_stamp[0]) - return self._data.time_stamp + return int(self._data["time_stamp"][0]) + return self._data["time_stamp"] @time_stamp.setter def time_stamp(self, val): if not self._data.flags.writeable: raise ValueError("This Sample instance is read-only") - self._data.time_stamp = val + self._data["time_stamp"] = val @property def sample_value(self): """value_dtype: """ - return self._data.sample_value + return self._data["sample_value"].view(_numpy.recarray) @sample_value.setter def sample_value(self, val): if not self._data.flags.writeable: raise ValueError("This Sample instance is read-only") - self._data.sample_value = val + self._data["sample_value"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef Sample obj if isinstance(key, int): key_ = key size = self._data.size @@ -21545,10 +21716,18 @@ cdef class Sample: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return Sample.from_data(self._data[key_:key_+1]) + obj = Sample.__new__(Sample) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == sample_dtype: - return Sample.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == sample_dtype: + obj = Sample.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -21573,8 +21752,7 @@ cdef class Sample: raise ValueError("data array must be 1D") if data.dtype != sample_dtype: raise ValueError("data array must be of dtype sample_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=sample_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -21594,10 +21772,8 @@ cdef class Sample: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlSample_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=sample_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=sample_dtype_record) obj._owner = owner - return obj @@ -21618,6 +21794,7 @@ cdef _get_vgpu_instance_utilization_sample_dtype_offsets(): }) vgpu_instance_utilization_sample_dtype = _get_vgpu_instance_utilization_sample_dtype_offsets() +cdef object vgpu_instance_utilization_sample_dtype_record = _numpy.dtype((_numpy.record, vgpu_instance_utilization_sample_dtype)) cdef class VgpuInstanceUtilizationSample: """Empty-initialize an array of `nvmlVgpuInstanceUtilizationSample_t`. @@ -21634,8 +21811,7 @@ cdef class VgpuInstanceUtilizationSample: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=vgpu_instance_utilization_sample_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=vgpu_instance_utilization_sample_dtype_record) assert self._data.itemsize == sizeof(nvmlVgpuInstanceUtilizationSample_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlVgpuInstanceUtilizationSample_t) }" @@ -21648,17 +21824,17 @@ cdef class VgpuInstanceUtilizationSample: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -21679,75 +21855,76 @@ cdef class VgpuInstanceUtilizationSample: def vgpu_instance(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.vgpu_instance[0]) - return self._data.vgpu_instance + return int(self._data["vgpu_instance"][0]) + return self._data["vgpu_instance"] @vgpu_instance.setter def vgpu_instance(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuInstanceUtilizationSample instance is read-only") - self._data.vgpu_instance = val + self._data["vgpu_instance"] = val @property def time_stamp(self): """Union[~_numpy.uint64, int]: """ if self._data.size == 1: - return int(self._data.time_stamp[0]) - return self._data.time_stamp + return int(self._data["time_stamp"][0]) + return self._data["time_stamp"] @time_stamp.setter def time_stamp(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuInstanceUtilizationSample instance is read-only") - self._data.time_stamp = val + self._data["time_stamp"] = val @property def sm_util(self): """value_dtype: """ - return self._data.sm_util + return self._data["sm_util"].view(_numpy.recarray) @sm_util.setter def sm_util(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuInstanceUtilizationSample instance is read-only") - self._data.sm_util = val + self._data["sm_util"] = val @property def mem_util(self): """value_dtype: """ - return self._data.mem_util + return self._data["mem_util"].view(_numpy.recarray) @mem_util.setter def mem_util(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuInstanceUtilizationSample instance is read-only") - self._data.mem_util = val + self._data["mem_util"] = val @property def enc_util(self): """value_dtype: """ - return self._data.enc_util + return self._data["enc_util"].view(_numpy.recarray) @enc_util.setter def enc_util(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuInstanceUtilizationSample instance is read-only") - self._data.enc_util = val + self._data["enc_util"] = val @property def dec_util(self): """value_dtype: """ - return self._data.dec_util + return self._data["dec_util"].view(_numpy.recarray) @dec_util.setter def dec_util(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuInstanceUtilizationSample instance is read-only") - self._data.dec_util = val + self._data["dec_util"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef VgpuInstanceUtilizationSample obj if isinstance(key, int): key_ = key size = self._data.size @@ -21755,10 +21932,18 @@ cdef class VgpuInstanceUtilizationSample: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return VgpuInstanceUtilizationSample.from_data(self._data[key_:key_+1]) + obj = VgpuInstanceUtilizationSample.__new__(VgpuInstanceUtilizationSample) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == vgpu_instance_utilization_sample_dtype: - return VgpuInstanceUtilizationSample.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == vgpu_instance_utilization_sample_dtype: + obj = VgpuInstanceUtilizationSample.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -21783,8 +21968,7 @@ cdef class VgpuInstanceUtilizationSample: raise ValueError("data array must be 1D") if data.dtype != vgpu_instance_utilization_sample_dtype: raise ValueError("data array must be of dtype vgpu_instance_utilization_sample_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=vgpu_instance_utilization_sample_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -21804,10 +21988,8 @@ cdef class VgpuInstanceUtilizationSample: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlVgpuInstanceUtilizationSample_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=vgpu_instance_utilization_sample_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=vgpu_instance_utilization_sample_dtype_record) obj._owner = owner - return obj @@ -21830,6 +22012,7 @@ cdef _get_vgpu_instance_utilization_info_v1_dtype_offsets(): }) vgpu_instance_utilization_info_v1_dtype = _get_vgpu_instance_utilization_info_v1_dtype_offsets() +cdef object vgpu_instance_utilization_info_v1_dtype_record = _numpy.dtype((_numpy.record, vgpu_instance_utilization_info_v1_dtype)) cdef class VgpuInstanceUtilizationInfo_v1: """Empty-initialize an array of `nvmlVgpuInstanceUtilizationInfo_v1_t`. @@ -21846,8 +22029,7 @@ cdef class VgpuInstanceUtilizationInfo_v1: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=vgpu_instance_utilization_info_v1_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=vgpu_instance_utilization_info_v1_dtype_record) assert self._data.itemsize == sizeof(nvmlVgpuInstanceUtilizationInfo_v1_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlVgpuInstanceUtilizationInfo_v1_t) }" @@ -21860,17 +22042,17 @@ cdef class VgpuInstanceUtilizationInfo_v1: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -21891,97 +22073,98 @@ cdef class VgpuInstanceUtilizationInfo_v1: def time_stamp(self): """Union[~_numpy.uint64, int]: CPU Timestamp in microseconds.""" if self._data.size == 1: - return int(self._data.time_stamp[0]) - return self._data.time_stamp + return int(self._data["time_stamp"][0]) + return self._data["time_stamp"] @time_stamp.setter def time_stamp(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuInstanceUtilizationInfo_v1 instance is read-only") - self._data.time_stamp = val + self._data["time_stamp"] = val @property def vgpu_instance(self): """Union[~_numpy.uint32, int]: vGPU Instance""" if self._data.size == 1: - return int(self._data.vgpu_instance[0]) - return self._data.vgpu_instance + return int(self._data["vgpu_instance"][0]) + return self._data["vgpu_instance"] @vgpu_instance.setter def vgpu_instance(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuInstanceUtilizationInfo_v1 instance is read-only") - self._data.vgpu_instance = val + self._data["vgpu_instance"] = val @property def sm_util(self): """value_dtype: SM (3D/Compute) Util Value.""" - return self._data.sm_util + return self._data["sm_util"].view(_numpy.recarray) @sm_util.setter def sm_util(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuInstanceUtilizationInfo_v1 instance is read-only") - self._data.sm_util = val + self._data["sm_util"] = val @property def mem_util(self): """value_dtype: Frame Buffer Memory Util Value.""" - return self._data.mem_util + return self._data["mem_util"].view(_numpy.recarray) @mem_util.setter def mem_util(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuInstanceUtilizationInfo_v1 instance is read-only") - self._data.mem_util = val + self._data["mem_util"] = val @property def enc_util(self): """value_dtype: Encoder Util Value.""" - return self._data.enc_util + return self._data["enc_util"].view(_numpy.recarray) @enc_util.setter def enc_util(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuInstanceUtilizationInfo_v1 instance is read-only") - self._data.enc_util = val + self._data["enc_util"] = val @property def dec_util(self): """value_dtype: Decoder Util Value.""" - return self._data.dec_util + return self._data["dec_util"].view(_numpy.recarray) @dec_util.setter def dec_util(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuInstanceUtilizationInfo_v1 instance is read-only") - self._data.dec_util = val + self._data["dec_util"] = val @property def jpg_util(self): """value_dtype: Jpeg Util Value.""" - return self._data.jpg_util + return self._data["jpg_util"].view(_numpy.recarray) @jpg_util.setter def jpg_util(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuInstanceUtilizationInfo_v1 instance is read-only") - self._data.jpg_util = val + self._data["jpg_util"] = val @property def ofa_util(self): """value_dtype: Ofa Util Value.""" - return self._data.ofa_util + return self._data["ofa_util"].view(_numpy.recarray) @ofa_util.setter def ofa_util(self, val): if not self._data.flags.writeable: raise ValueError("This VgpuInstanceUtilizationInfo_v1 instance is read-only") - self._data.ofa_util = val + self._data["ofa_util"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef VgpuInstanceUtilizationInfo_v1 obj if isinstance(key, int): key_ = key size = self._data.size @@ -21989,10 +22172,18 @@ cdef class VgpuInstanceUtilizationInfo_v1: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return VgpuInstanceUtilizationInfo_v1.from_data(self._data[key_:key_+1]) + obj = VgpuInstanceUtilizationInfo_v1.__new__(VgpuInstanceUtilizationInfo_v1) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == vgpu_instance_utilization_info_v1_dtype: - return VgpuInstanceUtilizationInfo_v1.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == vgpu_instance_utilization_info_v1_dtype: + obj = VgpuInstanceUtilizationInfo_v1.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -22017,8 +22208,7 @@ cdef class VgpuInstanceUtilizationInfo_v1: raise ValueError("data array must be 1D") if data.dtype != vgpu_instance_utilization_info_v1_dtype: raise ValueError("data array must be of dtype vgpu_instance_utilization_info_v1_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=vgpu_instance_utilization_info_v1_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -22038,10 +22228,8 @@ cdef class VgpuInstanceUtilizationInfo_v1: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlVgpuInstanceUtilizationInfo_v1_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=vgpu_instance_utilization_info_v1_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=vgpu_instance_utilization_info_v1_dtype_record) obj._owner = owner - return obj @@ -22063,6 +22251,7 @@ cdef _get_field_value_dtype_offsets(): }) field_value_dtype = _get_field_value_dtype_offsets() +cdef object field_value_dtype_record = _numpy.dtype((_numpy.record, field_value_dtype)) cdef class FieldValue: """Empty-initialize an array of `nvmlFieldValue_t`. @@ -22079,8 +22268,7 @@ cdef class FieldValue: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=field_value_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=field_value_dtype_record) assert self._data.itemsize == sizeof(nvmlFieldValue_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlFieldValue_t) }" @@ -22093,17 +22281,17 @@ cdef class FieldValue: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -22124,94 +22312,95 @@ cdef class FieldValue: def field_id(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.field_id[0]) - return self._data.field_id + return int(self._data["field_id"][0]) + return self._data["field_id"] @field_id.setter def field_id(self, val): if not self._data.flags.writeable: raise ValueError("This FieldValue instance is read-only") - self._data.field_id = val + self._data["field_id"] = val @property def scope_id(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.scope_id[0]) - return self._data.scope_id + return int(self._data["scope_id"][0]) + return self._data["scope_id"] @scope_id.setter def scope_id(self, val): if not self._data.flags.writeable: raise ValueError("This FieldValue instance is read-only") - self._data.scope_id = val + self._data["scope_id"] = val @property def timestamp(self): """Union[~_numpy.int64, int]: """ if self._data.size == 1: - return int(self._data.timestamp[0]) - return self._data.timestamp + return int(self._data["timestamp"][0]) + return self._data["timestamp"] @timestamp.setter def timestamp(self, val): if not self._data.flags.writeable: raise ValueError("This FieldValue instance is read-only") - self._data.timestamp = val + self._data["timestamp"] = val @property def latency_usec(self): """Union[~_numpy.int64, int]: """ if self._data.size == 1: - return int(self._data.latency_usec[0]) - return self._data.latency_usec + return int(self._data["latency_usec"][0]) + return self._data["latency_usec"] @latency_usec.setter def latency_usec(self, val): if not self._data.flags.writeable: raise ValueError("This FieldValue instance is read-only") - self._data.latency_usec = val + self._data["latency_usec"] = val @property def value_type(self): """Union[~_numpy.int32, int]: """ if self._data.size == 1: - return int(self._data.value_type[0]) - return self._data.value_type + return int(self._data["value_type"][0]) + return self._data["value_type"] @value_type.setter def value_type(self, val): if not self._data.flags.writeable: raise ValueError("This FieldValue instance is read-only") - self._data.value_type = val + self._data["value_type"] = val @property def nvml_return(self): """Union[~_numpy.int32, int]: """ if self._data.size == 1: - return int(self._data.nvml_return[0]) - return self._data.nvml_return + return int(self._data["nvml_return"][0]) + return self._data["nvml_return"] @nvml_return.setter def nvml_return(self, val): if not self._data.flags.writeable: raise ValueError("This FieldValue instance is read-only") - self._data.nvml_return = val + self._data["nvml_return"] = val @property def value(self): """value_dtype: """ - return self._data.value + return self._data["value"].view(_numpy.recarray) @value.setter def value(self, val): if not self._data.flags.writeable: raise ValueError("This FieldValue instance is read-only") - self._data.value = val + self._data["value"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef FieldValue obj if isinstance(key, int): key_ = key size = self._data.size @@ -22219,10 +22408,18 @@ cdef class FieldValue: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return FieldValue.from_data(self._data[key_:key_+1]) + obj = FieldValue.__new__(FieldValue) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == field_value_dtype: - return FieldValue.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == field_value_dtype: + obj = FieldValue.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -22247,8 +22444,7 @@ cdef class FieldValue: raise ValueError("data array must be 1D") if data.dtype != field_value_dtype: raise ValueError("data array must be of dtype field_value_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=field_value_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -22268,10 +22464,8 @@ cdef class FieldValue: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlFieldValue_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=field_value_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=field_value_dtype_record) obj._owner = owner - return obj @@ -23695,6 +23889,7 @@ cdef _get_grid_licensable_feature_dtype_offsets(): }) grid_licensable_feature_dtype = _get_grid_licensable_feature_dtype_offsets() +cdef object grid_licensable_feature_dtype_record = _numpy.dtype((_numpy.record, grid_licensable_feature_dtype)) cdef class GridLicensableFeature: """Empty-initialize an array of `nvmlGridLicensableFeature_t`. @@ -23711,8 +23906,7 @@ cdef class GridLicensableFeature: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=grid_licensable_feature_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=grid_licensable_feature_dtype_record) assert self._data.itemsize == sizeof(nvmlGridLicensableFeature_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlGridLicensableFeature_t) }" @@ -23725,17 +23919,17 @@ cdef class GridLicensableFeature: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -23756,77 +23950,78 @@ cdef class GridLicensableFeature: def feature_code(self): """Union[~_numpy.int32, int]: """ if self._data.size == 1: - return int(self._data.feature_code[0]) - return self._data.feature_code + return int(self._data["feature_code"][0]) + return self._data["feature_code"] @feature_code.setter def feature_code(self, val): if not self._data.flags.writeable: raise ValueError("This GridLicensableFeature instance is read-only") - self._data.feature_code = val + self._data["feature_code"] = val @property def feature_state(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.feature_state[0]) - return self._data.feature_state + return int(self._data["feature_state"][0]) + return self._data["feature_state"] @feature_state.setter def feature_state(self, val): if not self._data.flags.writeable: raise ValueError("This GridLicensableFeature instance is read-only") - self._data.feature_state = val + self._data["feature_state"] = val @property def license_info(self): """~_numpy.int8: (array of length 128).""" - return self._data.license_info + return self._data["license_info"] @license_info.setter def license_info(self, val): if not self._data.flags.writeable: raise ValueError("This GridLicensableFeature instance is read-only") - self._data.license_info = val + self._data["license_info"] = val @property def product_name(self): """~_numpy.int8: (array of length 128).""" - return self._data.product_name + return self._data["product_name"] @product_name.setter def product_name(self, val): if not self._data.flags.writeable: raise ValueError("This GridLicensableFeature instance is read-only") - self._data.product_name = val + self._data["product_name"] = val @property def feature_enabled(self): """Union[~_numpy.uint32, int]: """ if self._data.size == 1: - return int(self._data.feature_enabled[0]) - return self._data.feature_enabled + return int(self._data["feature_enabled"][0]) + return self._data["feature_enabled"] @feature_enabled.setter def feature_enabled(self, val): if not self._data.flags.writeable: raise ValueError("This GridLicensableFeature instance is read-only") - self._data.feature_enabled = val + self._data["feature_enabled"] = val @property def license_expiry(self): """grid_license_expiry_dtype: """ - return self._data.license_expiry + return self._data["license_expiry"].view(_numpy.recarray) @license_expiry.setter def license_expiry(self, val): if not self._data.flags.writeable: raise ValueError("This GridLicensableFeature instance is read-only") - self._data.license_expiry = val + self._data["license_expiry"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef GridLicensableFeature obj if isinstance(key, int): key_ = key size = self._data.size @@ -23834,10 +24029,18 @@ cdef class GridLicensableFeature: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return GridLicensableFeature.from_data(self._data[key_:key_+1]) + obj = GridLicensableFeature.__new__(GridLicensableFeature) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == grid_licensable_feature_dtype: - return GridLicensableFeature.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == grid_licensable_feature_dtype: + obj = GridLicensableFeature.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -23862,8 +24065,7 @@ cdef class GridLicensableFeature: raise ValueError("data array must be 1D") if data.dtype != grid_licensable_feature_dtype: raise ValueError("data array must be of dtype grid_licensable_feature_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=grid_licensable_feature_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -23883,10 +24085,8 @@ cdef class GridLicensableFeature: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlGridLicensableFeature_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=grid_licensable_feature_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=grid_licensable_feature_dtype_record) obj._owner = owner - return obj @@ -25251,6 +25451,7 @@ cdef _get_core_rail_metrics_dtype_offsets(): }) core_rail_metrics_dtype = _get_core_rail_metrics_dtype_offsets() +cdef object core_rail_metrics_dtype_record = _numpy.dtype((_numpy.record, core_rail_metrics_dtype)) cdef class CoreRailMetrics: """Empty-initialize an array of `nvmlCoreRailMetrics_t`. @@ -25267,8 +25468,7 @@ cdef class CoreRailMetrics: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=core_rail_metrics_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=core_rail_metrics_dtype_record) assert self._data.itemsize == sizeof(nvmlCoreRailMetrics_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlCoreRailMetrics_t) }" @@ -25281,17 +25481,17 @@ cdef class CoreRailMetrics: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -25311,17 +25511,18 @@ cdef class CoreRailMetrics: @property def rails(self): """rail_metrics_dtype: (array of length 2).Array of core rail metrics.""" - return self._data.rails + return self._data["rails"].view(_numpy.recarray) @rails.setter def rails(self, val): if not self._data.flags.writeable: raise ValueError("This CoreRailMetrics instance is read-only") - self._data.rails = val + self._data["rails"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef CoreRailMetrics obj if isinstance(key, int): key_ = key size = self._data.size @@ -25329,10 +25530,18 @@ cdef class CoreRailMetrics: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return CoreRailMetrics.from_data(self._data[key_:key_+1]) + obj = CoreRailMetrics.__new__(CoreRailMetrics) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == core_rail_metrics_dtype: - return CoreRailMetrics.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == core_rail_metrics_dtype: + obj = CoreRailMetrics.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -25357,8 +25566,7 @@ cdef class CoreRailMetrics: raise ValueError("data array must be 1D") if data.dtype != core_rail_metrics_dtype: raise ValueError("data array must be of dtype core_rail_metrics_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=core_rail_metrics_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -25378,10 +25586,8 @@ cdef class CoreRailMetrics: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlCoreRailMetrics_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=core_rail_metrics_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=core_rail_metrics_dtype_record) obj._owner = owner - return obj @@ -25402,6 +25608,7 @@ cdef _get_pwr_model_metrics_pfpp1x_dtype_offsets(): }) pwr_model_metrics_pfpp1x_dtype = _get_pwr_model_metrics_pfpp1x_dtype_offsets() +cdef object pwr_model_metrics_pfpp1x_dtype_record = _numpy.dtype((_numpy.record, pwr_model_metrics_pfpp1x_dtype)) cdef class PwrModelMetricsPfpp1x: """Empty-initialize an array of `nvmlPwrModelMetricsPfpp1x_t`. @@ -25419,18 +25626,9 @@ cdef class PwrModelMetricsPfpp1x: readonly tuple _estimated_metrics def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=pwr_model_metrics_pfpp1x_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=pwr_model_metrics_pfpp1x_dtype_record) assert self._data.itemsize == sizeof(nvmlPwrModelMetricsPfpp1x_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlPwrModelMetricsPfpp1x_t) }" - obj = self - estimated_metrics_list = list() - for i in range(obj._data.size): - addr = obj._data.estimated_metrics[i].__array_interface__['data'][0] - n = int(obj._data.num_vf_points[i]) - estimated_metrics_obj = PwrModelMetricsSamplePfpp1x.from_ptr(addr, n, owner=obj, readonly=False) - estimated_metrics_list.append(estimated_metrics_obj) - obj._estimated_metrics = tuple(estimated_metrics_list) def __repr__(self): if self._data.size > 1: @@ -25441,17 +25639,17 @@ cdef class PwrModelMetricsPfpp1x: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -25471,6 +25669,19 @@ cdef class PwrModelMetricsPfpp1x: @property def estimated_metrics(self): """PwrModelMetricsSamplePfpp1x: Array of estimated metrics for different operating points.""" + if self._estimated_metrics is None: + estimated_metrics_list = list() + estimated_metrics_base = _cyb_array_ptr(self._data) + estimated_metrics_offset = pwr_model_metrics_pfpp1x_dtype.fields["estimated_metrics"][1] + estimated_metrics_stride = self._data.strides[0] + estimated_metrics_readonly = not self._data.flags.writeable + estimated_metrics_sizes = self._data["num_vf_points"] + for i in range(self._data.size): + addr = estimated_metrics_base + i * estimated_metrics_stride + estimated_metrics_offset + n = int(estimated_metrics_sizes[i]) + estimated_metrics_obj = PwrModelMetricsSamplePfpp1x.from_ptr(addr, n, owner=self, readonly=estimated_metrics_readonly) + estimated_metrics_list.append(estimated_metrics_obj) + self._estimated_metrics = tuple(estimated_metrics_list) if self._data.size == 1: return self._estimated_metrics[0] return self._estimated_metrics @@ -25479,53 +25690,54 @@ cdef class PwrModelMetricsPfpp1x: def b_valid(self): """Union[~_numpy.uint8, int]: Validity flag: non-zero if metrics are valid.""" if self._data.size == 1: - return int(self._data.b_valid[0]) - return self._data.b_valid + return int(self._data["b_valid"][0]) + return self._data["b_valid"] @b_valid.setter def b_valid(self, val): if not self._data.flags.writeable: raise ValueError("This PwrModelMetricsPfpp1x instance is read-only") - self._data.b_valid = val + self._data["b_valid"] = val @property def max_perf_per_watt_point(self): """pwr_model_operating_point_pfpp1x_dtype: Operating point with maximum performance per watt.""" - return self._data.max_perf_per_watt_point + return self._data["max_perf_per_watt_point"].view(_numpy.recarray) @max_perf_per_watt_point.setter def max_perf_per_watt_point(self, val): if not self._data.flags.writeable: raise ValueError("This PwrModelMetricsPfpp1x instance is read-only") - self._data.max_perf_per_watt_point = val + self._data["max_perf_per_watt_point"] = val @property def fmax_at_vmax_point(self): """pwr_model_operating_point_pfpp1x_dtype: Operating point at maximum frequency and voltage.""" - return self._data.fmax_at_vmax_point + return self._data["fmax_at_vmax_point"].view(_numpy.recarray) @fmax_at_vmax_point.setter def fmax_at_vmax_point(self, val): if not self._data.flags.writeable: raise ValueError("This PwrModelMetricsPfpp1x instance is read-only") - self._data.fmax_at_vmax_point = val + self._data["fmax_at_vmax_point"] = val @property def tgp_headroomm_w(self): """Union[~_numpy.uint32, int]: TGP headroom in milliwatts.""" if self._data.size == 1: - return int(self._data.tgp_headroomm_w[0]) - return self._data.tgp_headroomm_w + return int(self._data["tgp_headroomm_w"][0]) + return self._data["tgp_headroomm_w"] @tgp_headroomm_w.setter def tgp_headroomm_w(self, val): if not self._data.flags.writeable: raise ValueError("This PwrModelMetricsPfpp1x instance is read-only") - self._data.tgp_headroomm_w = val + self._data["tgp_headroomm_w"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef PwrModelMetricsPfpp1x obj if isinstance(key, int): key_ = key size = self._data.size @@ -25533,10 +25745,18 @@ cdef class PwrModelMetricsPfpp1x: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return PwrModelMetricsPfpp1x.from_data(self._data[key_:key_+1]) + obj = PwrModelMetricsPfpp1x.__new__(PwrModelMetricsPfpp1x) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == pwr_model_metrics_pfpp1x_dtype: - return PwrModelMetricsPfpp1x.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == pwr_model_metrics_pfpp1x_dtype: + obj = PwrModelMetricsPfpp1x.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -25561,15 +25781,7 @@ cdef class PwrModelMetricsPfpp1x: raise ValueError("data array must be 1D") if data.dtype != pwr_model_metrics_pfpp1x_dtype: raise ValueError("data array must be of dtype pwr_model_metrics_pfpp1x_dtype") - obj._data = data.view(_numpy.recarray) - - estimated_metrics_list = list() - for i in range(obj._data.size): - addr = obj._data.estimated_metrics[i].__array_interface__['data'][0] - n = int(obj._data.num_vf_points[i]) - estimated_metrics_obj = PwrModelMetricsSamplePfpp1x.from_ptr(addr, n, owner=obj, readonly=False) - estimated_metrics_list.append(estimated_metrics_obj) - obj._estimated_metrics = tuple(estimated_metrics_list) + obj._data = data.view(dtype=pwr_model_metrics_pfpp1x_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -25589,17 +25801,8 @@ cdef class PwrModelMetricsPfpp1x: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlPwrModelMetricsPfpp1x_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=pwr_model_metrics_pfpp1x_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=pwr_model_metrics_pfpp1x_dtype_record) obj._owner = owner - - estimated_metrics_list = list() - for i in range(obj._data.size): - addr = obj._data.estimated_metrics[i].__array_interface__['data'][0] - n = int(obj._data.num_vf_points[i]) - estimated_metrics_obj = PwrModelMetricsSamplePfpp1x.from_ptr(addr, n, owner=obj, readonly=readonly) - estimated_metrics_list.append(estimated_metrics_obj) - obj._estimated_metrics = tuple(estimated_metrics_list) return obj @@ -26307,6 +26510,7 @@ cdef _get_prm_counter_v1_dtype_offsets(): }) prm_counter_v1_dtype = _get_prm_counter_v1_dtype_offsets() +cdef object prm_counter_v1_dtype_record = _numpy.dtype((_numpy.record, prm_counter_v1_dtype)) cdef class PRMCounter_v1: """Empty-initialize an array of `nvmlPRMCounter_v1_t`. @@ -26323,8 +26527,7 @@ cdef class PRMCounter_v1: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=prm_counter_v1_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=prm_counter_v1_dtype_record) assert self._data.itemsize == sizeof(nvmlPRMCounter_v1_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlPRMCounter_v1_t) }" @@ -26337,17 +26540,17 @@ cdef class PRMCounter_v1: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -26368,40 +26571,41 @@ cdef class PRMCounter_v1: def counter_id(self): """Union[~_numpy.uint32, int]: Counter ID, one of `nvmlPRMCounterId_t`.""" if self._data.size == 1: - return int(self._data.counter_id[0]) - return self._data.counter_id + return int(self._data["counter_id"][0]) + return self._data["counter_id"] @counter_id.setter def counter_id(self, val): if not self._data.flags.writeable: raise ValueError("This PRMCounter_v1 instance is read-only") - self._data.counter_id = val + self._data["counter_id"] = val @property def in_data(self): """prm_counter_input_v1_dtype: PRM input values.""" - return self._data.in_data + return self._data["in_data"].view(_numpy.recarray) @in_data.setter def in_data(self, val): if not self._data.flags.writeable: raise ValueError("This PRMCounter_v1 instance is read-only") - self._data.in_data = val + self._data["in_data"] = val @property def counter_value(self): """prm_counter_value_v1_dtype: Counter value.""" - return self._data.counter_value + return self._data["counter_value"].view(_numpy.recarray) @counter_value.setter def counter_value(self, val): if not self._data.flags.writeable: raise ValueError("This PRMCounter_v1 instance is read-only") - self._data.counter_value = val + self._data["counter_value"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef PRMCounter_v1 obj if isinstance(key, int): key_ = key size = self._data.size @@ -26409,10 +26613,18 @@ cdef class PRMCounter_v1: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return PRMCounter_v1.from_data(self._data[key_:key_+1]) + obj = PRMCounter_v1.__new__(PRMCounter_v1) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == prm_counter_v1_dtype: - return PRMCounter_v1.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == prm_counter_v1_dtype: + obj = PRMCounter_v1.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -26437,8 +26649,7 @@ cdef class PRMCounter_v1: raise ValueError("data array must be 1D") if data.dtype != prm_counter_v1_dtype: raise ValueError("data array must be of dtype prm_counter_v1_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=prm_counter_v1_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -26458,10 +26669,8 @@ cdef class PRMCounter_v1: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlPRMCounter_v1_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=prm_counter_v1_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=prm_counter_v1_dtype_record) obj._owner = owner - return obj @@ -27702,6 +27911,7 @@ cdef _get_pwr_model_metrics_dlppm1x_dtype_offsets(): }) pwr_model_metrics_dlppm1x_dtype = _get_pwr_model_metrics_dlppm1x_dtype_offsets() +cdef object pwr_model_metrics_dlppm1x_dtype_record = _numpy.dtype((_numpy.record, pwr_model_metrics_dlppm1x_dtype)) cdef class PwrModelMetricsDlppm1x: """Empty-initialize an array of `nvmlPwrModelMetricsDlppm1x_t`. @@ -27718,8 +27928,7 @@ cdef class PwrModelMetricsDlppm1x: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=pwr_model_metrics_dlppm1x_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=pwr_model_metrics_dlppm1x_dtype_record) assert self._data.itemsize == sizeof(nvmlPwrModelMetricsDlppm1x_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlPwrModelMetricsDlppm1x_t) }" @@ -27732,17 +27941,17 @@ cdef class PwrModelMetricsDlppm1x: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -27763,62 +27972,63 @@ cdef class PwrModelMetricsDlppm1x: def b_valid(self): """Union[~_numpy.uint8, int]: Validity flag: non-zero if metrics are valid.""" if self._data.size == 1: - return int(self._data.b_valid[0]) - return self._data.b_valid + return int(self._data["b_valid"][0]) + return self._data["b_valid"] @b_valid.setter def b_valid(self, val): if not self._data.flags.writeable: raise ValueError("This PwrModelMetricsDlppm1x instance is read-only") - self._data.b_valid = val + self._data["b_valid"] = val @property def core_rail(self): """core_rail_metrics_dtype: Core rail metrics.""" - return self._data.core_rail + return self._data["core_rail"].view(_numpy.recarray) @core_rail.setter def core_rail(self, val): if not self._data.flags.writeable: raise ValueError("This PwrModelMetricsDlppm1x instance is read-only") - self._data.core_rail = val + self._data["core_rail"] = val @property def fb_rail(self): """rail_metrics_dtype: Fb rail metrics.""" - return self._data.fb_rail + return self._data["fb_rail"].view(_numpy.recarray) @fb_rail.setter def fb_rail(self, val): if not self._data.flags.writeable: raise ValueError("This PwrModelMetricsDlppm1x instance is read-only") - self._data.fb_rail = val + self._data["fb_rail"] = val @property def tgp_pwr_tuple(self): """pmgr_pwr_tuple_dtype: Total Graphics Power (TGP) in milliwatts.""" - return self._data.tgp_pwr_tuple + return self._data["tgp_pwr_tuple"].view(_numpy.recarray) @tgp_pwr_tuple.setter def tgp_pwr_tuple(self, val): if not self._data.flags.writeable: raise ValueError("This PwrModelMetricsDlppm1x instance is read-only") - self._data.tgp_pwr_tuple = val + self._data["tgp_pwr_tuple"] = val @property def perf_metrics(self): """pwr_model_metrics_dlppm1x_perf_dtype: Performance metrics.""" - return self._data.perf_metrics + return self._data["perf_metrics"].view(_numpy.recarray) @perf_metrics.setter def perf_metrics(self, val): if not self._data.flags.writeable: raise ValueError("This PwrModelMetricsDlppm1x instance is read-only") - self._data.perf_metrics = val + self._data["perf_metrics"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef PwrModelMetricsDlppm1x obj if isinstance(key, int): key_ = key size = self._data.size @@ -27826,10 +28036,18 @@ cdef class PwrModelMetricsDlppm1x: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return PwrModelMetricsDlppm1x.from_data(self._data[key_:key_+1]) + obj = PwrModelMetricsDlppm1x.__new__(PwrModelMetricsDlppm1x) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == pwr_model_metrics_dlppm1x_dtype: - return PwrModelMetricsDlppm1x.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == pwr_model_metrics_dlppm1x_dtype: + obj = PwrModelMetricsDlppm1x.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -27854,8 +28072,7 @@ cdef class PwrModelMetricsDlppm1x: raise ValueError("data array must be 1D") if data.dtype != pwr_model_metrics_dlppm1x_dtype: raise ValueError("data array must be of dtype pwr_model_metrics_dlppm1x_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=pwr_model_metrics_dlppm1x_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -27875,10 +28092,8 @@ cdef class PwrModelMetricsDlppm1x: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlPwrModelMetricsDlppm1x_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=pwr_model_metrics_dlppm1x_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=pwr_model_metrics_dlppm1x_dtype_record) obj._owner = owner - return obj @@ -27894,6 +28109,7 @@ cdef _get_perf_metrics_pfpp1x_sample_dtype_offsets(): }) perf_metrics_pfpp1x_sample_dtype = _get_perf_metrics_pfpp1x_sample_dtype_offsets() +cdef object perf_metrics_pfpp1x_sample_dtype_record = _numpy.dtype((_numpy.record, perf_metrics_pfpp1x_sample_dtype)) cdef class PerfMetricsPfpp1xSample: """Empty-initialize an array of `nvmlPerfMetricsPfpp1xSample_t`. @@ -27910,8 +28126,7 @@ cdef class PerfMetricsPfpp1xSample: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=perf_metrics_pfpp1x_sample_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=perf_metrics_pfpp1x_sample_dtype_record) assert self._data.itemsize == sizeof(nvmlPerfMetricsPfpp1xSample_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlPerfMetricsPfpp1xSample_t) }" @@ -27924,17 +28139,17 @@ cdef class PerfMetricsPfpp1xSample: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -27954,17 +28169,18 @@ cdef class PerfMetricsPfpp1xSample: @property def estimated_metrics(self): """pwr_model_metrics_pfpp1x_dtype: Estimated metrics from the PFPP 1x controller.""" - return self._data.estimated_metrics + return self._data["estimated_metrics"].view(_numpy.recarray) @estimated_metrics.setter def estimated_metrics(self, val): if not self._data.flags.writeable: raise ValueError("This PerfMetricsPfpp1xSample instance is read-only") - self._data.estimated_metrics = val + self._data["estimated_metrics"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef PerfMetricsPfpp1xSample obj if isinstance(key, int): key_ = key size = self._data.size @@ -27972,10 +28188,18 @@ cdef class PerfMetricsPfpp1xSample: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return PerfMetricsPfpp1xSample.from_data(self._data[key_:key_+1]) + obj = PerfMetricsPfpp1xSample.__new__(PerfMetricsPfpp1xSample) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == perf_metrics_pfpp1x_sample_dtype: - return PerfMetricsPfpp1xSample.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == perf_metrics_pfpp1x_sample_dtype: + obj = PerfMetricsPfpp1xSample.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -28000,8 +28224,7 @@ cdef class PerfMetricsPfpp1xSample: raise ValueError("data array must be 1D") if data.dtype != perf_metrics_pfpp1x_sample_dtype: raise ValueError("data array must be of dtype perf_metrics_pfpp1x_sample_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=perf_metrics_pfpp1x_sample_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -28021,10 +28244,8 @@ cdef class PerfMetricsPfpp1xSample: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlPerfMetricsPfpp1xSample_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=perf_metrics_pfpp1x_sample_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=perf_metrics_pfpp1x_sample_dtype_record) obj._owner = owner - return obj @@ -28041,6 +28262,7 @@ cdef _get_pwr_model_metrics_dlppm1x_dramclk_estimates_dtype_offsets(): }) pwr_model_metrics_dlppm1x_dramclk_estimates_dtype = _get_pwr_model_metrics_dlppm1x_dramclk_estimates_dtype_offsets() +cdef object pwr_model_metrics_dlppm1x_dramclk_estimates_dtype_record = _numpy.dtype((_numpy.record, pwr_model_metrics_dlppm1x_dramclk_estimates_dtype)) cdef class PwrModelMetricsDlppm1xDramclkEstimates: """Empty-initialize an array of `nvmlPwrModelMetricsDlppm1xDramclkEstimates_t`. @@ -28058,18 +28280,9 @@ cdef class PwrModelMetricsDlppm1xDramclkEstimates: readonly tuple _estimated_metrics def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=pwr_model_metrics_dlppm1x_dramclk_estimates_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=pwr_model_metrics_dlppm1x_dramclk_estimates_dtype_record) assert self._data.itemsize == sizeof(nvmlPwrModelMetricsDlppm1xDramclkEstimates_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlPwrModelMetricsDlppm1xDramclkEstimates_t) }" - obj = self - estimated_metrics_list = list() - for i in range(obj._data.size): - addr = obj._data.estimated_metrics[i].__array_interface__['data'][0] - n = int(obj._data.num_estimated_metrics[i]) - estimated_metrics_obj = PwrModelMetricsDlppm1x.from_ptr(addr, n, owner=obj, readonly=False) - estimated_metrics_list.append(estimated_metrics_obj) - obj._estimated_metrics = tuple(estimated_metrics_list) def __repr__(self): if self._data.size > 1: @@ -28080,17 +28293,17 @@ cdef class PwrModelMetricsDlppm1xDramclkEstimates: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -28110,6 +28323,19 @@ cdef class PwrModelMetricsDlppm1xDramclkEstimates: @property def estimated_metrics(self): """PwrModelMetricsDlppm1x: Array of estimated metrics for each inference loop.""" + if self._estimated_metrics is None: + estimated_metrics_list = list() + estimated_metrics_base = _cyb_array_ptr(self._data) + estimated_metrics_offset = pwr_model_metrics_dlppm1x_dramclk_estimates_dtype.fields["estimated_metrics"][1] + estimated_metrics_stride = self._data.strides[0] + estimated_metrics_readonly = not self._data.flags.writeable + estimated_metrics_sizes = self._data["num_estimated_metrics"] + for i in range(self._data.size): + addr = estimated_metrics_base + i * estimated_metrics_stride + estimated_metrics_offset + n = int(estimated_metrics_sizes[i]) + estimated_metrics_obj = PwrModelMetricsDlppm1x.from_ptr(addr, n, owner=self, readonly=estimated_metrics_readonly) + estimated_metrics_list.append(estimated_metrics_obj) + self._estimated_metrics = tuple(estimated_metrics_list) if self._data.size == 1: return self._estimated_metrics[0] return self._estimated_metrics @@ -28117,6 +28343,7 @@ cdef class PwrModelMetricsDlppm1xDramclkEstimates: def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef PwrModelMetricsDlppm1xDramclkEstimates obj if isinstance(key, int): key_ = key size = self._data.size @@ -28124,10 +28351,18 @@ cdef class PwrModelMetricsDlppm1xDramclkEstimates: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return PwrModelMetricsDlppm1xDramclkEstimates.from_data(self._data[key_:key_+1]) + obj = PwrModelMetricsDlppm1xDramclkEstimates.__new__(PwrModelMetricsDlppm1xDramclkEstimates) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == pwr_model_metrics_dlppm1x_dramclk_estimates_dtype: - return PwrModelMetricsDlppm1xDramclkEstimates.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == pwr_model_metrics_dlppm1x_dramclk_estimates_dtype: + obj = PwrModelMetricsDlppm1xDramclkEstimates.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -28152,15 +28387,7 @@ cdef class PwrModelMetricsDlppm1xDramclkEstimates: raise ValueError("data array must be 1D") if data.dtype != pwr_model_metrics_dlppm1x_dramclk_estimates_dtype: raise ValueError("data array must be of dtype pwr_model_metrics_dlppm1x_dramclk_estimates_dtype") - obj._data = data.view(_numpy.recarray) - - estimated_metrics_list = list() - for i in range(obj._data.size): - addr = obj._data.estimated_metrics[i].__array_interface__['data'][0] - n = int(obj._data.num_estimated_metrics[i]) - estimated_metrics_obj = PwrModelMetricsDlppm1x.from_ptr(addr, n, owner=obj, readonly=False) - estimated_metrics_list.append(estimated_metrics_obj) - obj._estimated_metrics = tuple(estimated_metrics_list) + obj._data = data.view(dtype=pwr_model_metrics_dlppm1x_dramclk_estimates_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -28180,17 +28407,8 @@ cdef class PwrModelMetricsDlppm1xDramclkEstimates: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlPwrModelMetricsDlppm1xDramclkEstimates_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=pwr_model_metrics_dlppm1x_dramclk_estimates_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=pwr_model_metrics_dlppm1x_dramclk_estimates_dtype_record) obj._owner = owner - - estimated_metrics_list = list() - for i in range(obj._data.size): - addr = obj._data.estimated_metrics[i].__array_interface__['data'][0] - n = int(obj._data.num_estimated_metrics[i]) - estimated_metrics_obj = PwrModelMetricsDlppm1x.from_ptr(addr, n, owner=obj, readonly=readonly) - estimated_metrics_list.append(estimated_metrics_obj) - obj._estimated_metrics = tuple(estimated_metrics_list) return obj @@ -28211,6 +28429,7 @@ cdef _get_observed_metrics_dtype_offsets(): }) observed_metrics_dtype = _get_observed_metrics_dtype_offsets() +cdef object observed_metrics_dtype_record = _numpy.dtype((_numpy.record, observed_metrics_dtype)) cdef class ObservedMetrics: """Empty-initialize an array of `nvmlObservedMetrics_t`. @@ -28227,8 +28446,7 @@ cdef class ObservedMetrics: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=observed_metrics_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=observed_metrics_dtype_record) assert self._data.itemsize == sizeof(nvmlObservedMetrics_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlObservedMetrics_t) }" @@ -28241,17 +28459,17 @@ cdef class ObservedMetrics: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -28271,74 +28489,75 @@ cdef class ObservedMetrics: @property def initial_dramclk_est(self): """pwr_model_metrics_dlppm1x_dramclk_estimates_dtype: (array of length 3).Initial DRAMCLK estimates for different scenarios.""" - return self._data.initial_dramclk_est + return self._data["initial_dramclk_est"].view(_numpy.recarray) @initial_dramclk_est.setter def initial_dramclk_est(self, val): if not self._data.flags.writeable: raise ValueError("This ObservedMetrics instance is read-only") - self._data.initial_dramclk_est = val + self._data["initial_dramclk_est"] = val @property def b_valid(self): """Union[~_numpy.uint8, int]: Validity flag: non-zero if observed metrics are valid.""" if self._data.size == 1: - return int(self._data.b_valid[0]) - return self._data.b_valid + return int(self._data["b_valid"][0]) + return self._data["b_valid"] @b_valid.setter def b_valid(self, val): if not self._data.flags.writeable: raise ValueError("This ObservedMetrics instance is read-only") - self._data.b_valid = val + self._data["b_valid"] = val @property def core_rail(self): """core_rail_metrics_dtype: Observed core rail metrics.""" - return self._data.core_rail + return self._data["core_rail"].view(_numpy.recarray) @core_rail.setter def core_rail(self, val): if not self._data.flags.writeable: raise ValueError("This ObservedMetrics instance is read-only") - self._data.core_rail = val + self._data["core_rail"] = val @property def fb_rail(self): """rail_metrics_dtype: Observed fb rail metrics.""" - return self._data.fb_rail + return self._data["fb_rail"].view(_numpy.recarray) @fb_rail.setter def fb_rail(self, val): if not self._data.flags.writeable: raise ValueError("This ObservedMetrics instance is read-only") - self._data.fb_rail = val + self._data["fb_rail"] = val @property def tgp_pwr_tuple(self): """pmgr_pwr_tuple_dtype: Observed Total Graphics Power (TGP) in milliwatts.""" - return self._data.tgp_pwr_tuple + return self._data["tgp_pwr_tuple"].view(_numpy.recarray) @tgp_pwr_tuple.setter def tgp_pwr_tuple(self, val): if not self._data.flags.writeable: raise ValueError("This ObservedMetrics instance is read-only") - self._data.tgp_pwr_tuple = val + self._data["tgp_pwr_tuple"] = val @property def perf_metrics(self): """pwr_model_metrics_dlppm1x_perf_dtype: Observed performance metrics.""" - return self._data.perf_metrics + return self._data["perf_metrics"].view(_numpy.recarray) @perf_metrics.setter def perf_metrics(self, val): if not self._data.flags.writeable: raise ValueError("This ObservedMetrics instance is read-only") - self._data.perf_metrics = val + self._data["perf_metrics"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef ObservedMetrics obj if isinstance(key, int): key_ = key size = self._data.size @@ -28346,10 +28565,18 @@ cdef class ObservedMetrics: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return ObservedMetrics.from_data(self._data[key_:key_+1]) + obj = ObservedMetrics.__new__(ObservedMetrics) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == observed_metrics_dtype: - return ObservedMetrics.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == observed_metrics_dtype: + obj = ObservedMetrics.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -28374,8 +28601,7 @@ cdef class ObservedMetrics: raise ValueError("data array must be 1D") if data.dtype != observed_metrics_dtype: raise ValueError("data array must be of dtype observed_metrics_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=observed_metrics_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -28395,10 +28621,8 @@ cdef class ObservedMetrics: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlObservedMetrics_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=observed_metrics_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=observed_metrics_dtype_record) obj._owner = owner - return obj @@ -28414,6 +28638,7 @@ cdef _get_perf_metrics_dlppc2x_sample_dtype_offsets(): }) perf_metrics_dlppc2x_sample_dtype = _get_perf_metrics_dlppc2x_sample_dtype_offsets() +cdef object perf_metrics_dlppc2x_sample_dtype_record = _numpy.dtype((_numpy.record, perf_metrics_dlppc2x_sample_dtype)) cdef class PerfMetricsDlppc2xSample: """Empty-initialize an array of `nvmlPerfMetricsDlppc2xSample_t`. @@ -28430,8 +28655,7 @@ cdef class PerfMetricsDlppc2xSample: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=perf_metrics_dlppc2x_sample_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=perf_metrics_dlppc2x_sample_dtype_record) assert self._data.itemsize == sizeof(nvmlPerfMetricsDlppc2xSample_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlPerfMetricsDlppc2xSample_t) }" @@ -28444,17 +28668,17 @@ cdef class PerfMetricsDlppc2xSample: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -28474,17 +28698,18 @@ cdef class PerfMetricsDlppc2xSample: @property def observed_metrics(self): """observed_metrics_dtype: Observed metrics from the DLPPC 2x controller.""" - return self._data.observed_metrics + return self._data["observed_metrics"].view(_numpy.recarray) @observed_metrics.setter def observed_metrics(self, val): if not self._data.flags.writeable: raise ValueError("This PerfMetricsDlppc2xSample instance is read-only") - self._data.observed_metrics = val + self._data["observed_metrics"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef PerfMetricsDlppc2xSample obj if isinstance(key, int): key_ = key size = self._data.size @@ -28492,10 +28717,18 @@ cdef class PerfMetricsDlppc2xSample: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return PerfMetricsDlppc2xSample.from_data(self._data[key_:key_+1]) + obj = PerfMetricsDlppc2xSample.__new__(PerfMetricsDlppc2xSample) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == perf_metrics_dlppc2x_sample_dtype: - return PerfMetricsDlppc2xSample.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == perf_metrics_dlppc2x_sample_dtype: + obj = PerfMetricsDlppc2xSample.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -28520,8 +28753,7 @@ cdef class PerfMetricsDlppc2xSample: raise ValueError("data array must be 1D") if data.dtype != perf_metrics_dlppc2x_sample_dtype: raise ValueError("data array must be of dtype perf_metrics_dlppc2x_sample_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=perf_metrics_dlppc2x_sample_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -28541,10 +28773,8 @@ cdef class PerfMetricsDlppc2xSample: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlPerfMetricsDlppc2xSample_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=perf_metrics_dlppc2x_sample_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=perf_metrics_dlppc2x_sample_dtype_record) obj._owner = owner - return obj @@ -28722,6 +28952,7 @@ cdef _get_perf_metric_controller_sample_dtype_offsets(): }) perf_metric_controller_sample_dtype = _get_perf_metric_controller_sample_dtype_offsets() +cdef object perf_metric_controller_sample_dtype_record = _numpy.dtype((_numpy.record, perf_metric_controller_sample_dtype)) cdef class PerfMetricControllerSample: """Empty-initialize an array of `nvmlPerfMetricControllerSample_t`. @@ -28738,8 +28969,7 @@ cdef class PerfMetricControllerSample: object _owner def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=perf_metric_controller_sample_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=perf_metric_controller_sample_dtype_record) assert self._data.itemsize == sizeof(nvmlPerfMetricControllerSample_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlPerfMetricControllerSample_t) }" @@ -28752,17 +28982,17 @@ cdef class PerfMetricControllerSample: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -28783,29 +29013,30 @@ cdef class PerfMetricControllerSample: def controller_type(self): """Union[~_numpy.uint32, int]: Controller type: NVML_PERF_METRICS_CONTROLLER_TYPE_DLPPC_2X or NVML_PERF_METRICS_CONTROLLER_TYPE_PFPP_1X.""" if self._data.size == 1: - return int(self._data.controller_type[0]) - return self._data.controller_type + return int(self._data["controller_type"][0]) + return self._data["controller_type"] @controller_type.setter def controller_type(self, val): if not self._data.flags.writeable: raise ValueError("This PerfMetricControllerSample instance is read-only") - self._data.controller_type = val + self._data["controller_type"] = val @property def data_(self): """_py_anon_pod8_dtype: Union containing controller-specific data.""" - return self._data.data_ + return self._data["data_"].view(_numpy.recarray) @data_.setter def data_(self, val): if not self._data.flags.writeable: raise ValueError("This PerfMetricControllerSample instance is read-only") - self._data.data_ = val + self._data["data_"] = val def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef PerfMetricControllerSample obj if isinstance(key, int): key_ = key size = self._data.size @@ -28813,10 +29044,18 @@ cdef class PerfMetricControllerSample: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return PerfMetricControllerSample.from_data(self._data[key_:key_+1]) + obj = PerfMetricControllerSample.__new__(PerfMetricControllerSample) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == perf_metric_controller_sample_dtype: - return PerfMetricControllerSample.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == perf_metric_controller_sample_dtype: + obj = PerfMetricControllerSample.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -28841,8 +29080,7 @@ cdef class PerfMetricControllerSample: raise ValueError("data array must be 1D") if data.dtype != perf_metric_controller_sample_dtype: raise ValueError("data array must be of dtype perf_metric_controller_sample_dtype") - obj._data = data.view(_numpy.recarray) - + obj._data = data.view(dtype=perf_metric_controller_sample_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -28862,10 +29100,8 @@ cdef class PerfMetricControllerSample: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlPerfMetricControllerSample_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=perf_metric_controller_sample_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=perf_metric_controller_sample_dtype_record) obj._owner = owner - return obj @@ -28882,6 +29118,7 @@ cdef _get_perf_metrics_sample_dtype_offsets(): }) perf_metrics_sample_dtype = _get_perf_metrics_sample_dtype_offsets() +cdef object perf_metrics_sample_dtype_record = _numpy.dtype((_numpy.record, perf_metrics_sample_dtype)) cdef class PerfMetricsSample: """Empty-initialize an array of `nvmlPerfMetricsSample_t`. @@ -28899,18 +29136,9 @@ cdef class PerfMetricsSample: readonly tuple _controller_data def __init__(self, size=1): - arr = _numpy.zeros(size, dtype=perf_metrics_sample_dtype) - self._data = arr.view(_numpy.recarray) + self._data = _numpy.zeros(size, dtype=perf_metrics_sample_dtype_record) assert self._data.itemsize == sizeof(nvmlPerfMetricsSample_t), \ f"itemsize {self._data.itemsize} mismatches struct size { sizeof(nvmlPerfMetricsSample_t) }" - obj = self - controller_data_list = list() - for i in range(obj._data.size): - addr = obj._data.controller_data[i].__array_interface__['data'][0] - n = int(obj._data.num_controller_data[i]) - controller_data_obj = PerfMetricControllerSample.from_ptr(addr, n, owner=obj, readonly=False) - controller_data_list.append(controller_data_obj) - obj._controller_data = tuple(controller_data_list) def __repr__(self): if self._data.size > 1: @@ -28921,17 +29149,17 @@ cdef class PerfMetricsSample: @property def ptr(self): """Get the pointer address to the data as Python :class:`int`.""" - return self._data.ctypes.data + return _cyb_array_ptr(self._data) cdef intptr_t _get_ptr(self): - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __int__(self): if self._data.size > 1 and not self._data.flags["C_CONTIGUOUS"]: raise TypeError("int() argument must be a bytes-like object of size 1, or a " "C-contiguous array. To get the pointer address of a " "non-contiguous array, use .ptr") - return self._data.ctypes.data + return _cyb_array_ptr(self._data) def __len__(self): return self._data.size @@ -28951,6 +29179,19 @@ cdef class PerfMetricsSample: @property def controller_data(self): """PerfMetricControllerSample: Array of controller samples.""" + if self._controller_data is None: + controller_data_list = list() + controller_data_base = _cyb_array_ptr(self._data) + controller_data_offset = perf_metrics_sample_dtype.fields["controller_data"][1] + controller_data_stride = self._data.strides[0] + controller_data_readonly = not self._data.flags.writeable + controller_data_sizes = self._data["num_controller_data"] + for i in range(self._data.size): + addr = controller_data_base + i * controller_data_stride + controller_data_offset + n = int(controller_data_sizes[i]) + controller_data_obj = PerfMetricControllerSample.from_ptr(addr, n, owner=self, readonly=controller_data_readonly) + controller_data_list.append(controller_data_obj) + self._controller_data = tuple(controller_data_list) if self._data.size == 1: return self._controller_data[0] return self._controller_data @@ -28958,6 +29199,7 @@ cdef class PerfMetricsSample: def __getitem__(self, key): cdef ssize_t key_ cdef ssize_t size + cdef PerfMetricsSample obj if isinstance(key, int): key_ = key size = self._data.size @@ -28965,10 +29207,18 @@ cdef class PerfMetricsSample: raise IndexError("index is out of bounds") if key_ < 0: key_ += size - return PerfMetricsSample.from_data(self._data[key_:key_+1]) + obj = PerfMetricsSample.__new__(PerfMetricsSample) + obj._data = self._data[key_:key_+1] + obj._owner = self._owner + return obj out = self._data[key] - if isinstance(out, _numpy.recarray) and out.dtype == perf_metrics_sample_dtype: - return PerfMetricsSample.from_data(out) + if isinstance(out, _numpy.ndarray): + if out.dtype == perf_metrics_sample_dtype: + obj = PerfMetricsSample.from_data(out) + obj._owner = self._owner + return obj + if out.dtype.names is not None: + return out.view(_numpy.recarray) return out def __setitem__(self, key, val): @@ -28993,15 +29243,7 @@ cdef class PerfMetricsSample: raise ValueError("data array must be 1D") if data.dtype != perf_metrics_sample_dtype: raise ValueError("data array must be of dtype perf_metrics_sample_dtype") - obj._data = data.view(_numpy.recarray) - - controller_data_list = list() - for i in range(obj._data.size): - addr = obj._data.controller_data[i].__array_interface__['data'][0] - n = int(obj._data.num_controller_data[i]) - controller_data_obj = PerfMetricControllerSample.from_ptr(addr, n, owner=obj, readonly=False) - controller_data_list.append(controller_data_obj) - obj._controller_data = tuple(controller_data_list) + obj._data = data.view(dtype=perf_metrics_sample_dtype_record, type=_numpy.ndarray) return obj @staticmethod @@ -29021,17 +29263,8 @@ cdef class PerfMetricsSample: cdef flag = _cyb_cpython_buffer.PyBUF_READ if readonly else _cyb_cpython_buffer.PyBUF_WRITE cdef object buf = _cyb_cpython_memoryview.PyMemoryView_FromMemory( ptr, sizeof(nvmlPerfMetricsSample_t) * size, flag) - data = _numpy.ndarray(size, buffer=buf, dtype=perf_metrics_sample_dtype) - obj._data = data.view(_numpy.recarray) + obj._data = _numpy.ndarray(size, buffer=buf, dtype=perf_metrics_sample_dtype_record) obj._owner = owner - - controller_data_list = list() - for i in range(obj._data.size): - addr = obj._data.controller_data[i].__array_interface__['data'][0] - n = int(obj._data.num_controller_data[i]) - controller_data_obj = PerfMetricControllerSample.from_ptr(addr, n, owner=obj, readonly=readonly) - controller_data_list.append(controller_data_obj) - obj._controller_data = tuple(controller_data_list) return obj diff --git a/cuda_bindings_13/docs/source/release/13.5.0-notes.rst b/cuda_bindings_13/docs/source/release/13.5.0-notes.rst index 59373f5ca5f..a49924a9806 100644 --- a/cuda_bindings_13/docs/source/release/13.5.0-notes.rst +++ b/cuda_bindings_13/docs/source/release/13.5.0-notes.rst @@ -327,6 +327,7 @@ Enhancements - For all ``cuda-bindings`` APIs, functions that accept a struct wrapper will accept the struct wrapper directly, rather than requiring getting the ``.ptr`` property. - Creating class instances in ``cuda-bindings`` should now be faster in most cases, because it requires 1 heap allocation rather than 2. - Before a source build compiles anything, it now checks that the CUDA Toolkit's ``cuda.h`` has the major.minor the source tree was generated from. A mismatch stops the build with a message that names the header found and the version needed. Previously a mismatch surfaced as a long list of C++ redefinition errors. +- Wrappers of arrays of CUDA structs are now 5x - 30x faster for most common operations (thanks to a contribution from Yang Gao). This affects ``cufile``, ``nvml`` and ``_v2.driver``. Behavior changes ----------------