From cc9e846e466d33d4c7fe019f465c59f115a9a9c5 Mon Sep 17 00:00:00 2001 From: Michael Droettboom Date: Fri, 17 Jul 2026 09:30:50 -0400 Subject: [PATCH] Fix potential data race in initialization --- .../cuda/bindings/_internal/cufile_linux.pyx | 40 +++++++++++++++++-- .../cuda/bindings/_internal/driver_linux.pyx | 40 +++++++++++++++++-- .../bindings/_internal/driver_windows.pyx | 40 +++++++++++++++++-- .../bindings/_internal/nvfatbin_linux.pyx | 40 +++++++++++++++++-- .../bindings/_internal/nvfatbin_windows.pyx | 40 +++++++++++++++++-- .../bindings/_internal/nvjitlink_linux.pyx | 40 +++++++++++++++++-- .../bindings/_internal/nvjitlink_windows.pyx | 40 +++++++++++++++++-- .../cuda/bindings/_internal/nvml_linux.pyx | 40 +++++++++++++++++-- .../cuda/bindings/_internal/nvml_windows.pyx | 40 +++++++++++++++++-- .../cuda/bindings/_internal/nvrtc_linux.pyx | 40 +++++++++++++++++-- .../cuda/bindings/_internal/nvrtc_windows.pyx | 40 +++++++++++++++++-- .../cuda/bindings/_internal/nvvm_linux.pyx | 40 +++++++++++++++++-- .../cuda/bindings/_internal/nvvm_windows.pyx | 40 +++++++++++++++++-- cuda_bindings/cuda/bindings/cydriver.pxd | 8 ++-- cuda_bindings/cuda/bindings/cynvrtc.pxd | 4 +- 15 files changed, 474 insertions(+), 58 deletions(-) diff --git a/cuda_bindings/cuda/bindings/_internal/cufile_linux.pyx b/cuda_bindings/cuda/bindings/_internal/cufile_linux.pyx index eb483298343..53339f575f2 100644 --- a/cuda_bindings/cuda/bindings/_internal/cufile_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/cufile_linux.pyx @@ -3,11 +3,43 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated with version 12.9.1. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=024982f0bae1e5b410017fc993255a308efb8b4811b34b2b1e90a44e54c27247 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=f82fe2e4ea86565b1f096aad374d6d4578d37de77db0518cd7e2c73332dfb78f # <<<< PREAMBLE CONTENT >>>> +cdef extern from * nogil: + """ + #if defined(_MSC_VER) && !defined(__clang__) + #include + static __forceinline int atomic_int_load(int *p) { + int v = *(int volatile *)p; _ReadBarrier(); return v; + } + static __forceinline void atomic_int_store(int *p, int v) { + _WriteBarrier(); *(int volatile *)p = v; + } + #elif defined(__cplusplus) + /* GCC/Clang __atomic builtins work in any C++ standard without headers */ + static inline int atomic_int_load(int *p) { + return __atomic_load_n(p, __ATOMIC_ACQUIRE); + } + static inline void atomic_int_store(int *p, int v) { + __atomic_store_n(p, v, __ATOMIC_RELEASE); + } + #else + #include + static inline int atomic_int_load(int *p) { + return (int)atomic_load_explicit((atomic_int *)p, memory_order_acquire); + } + static inline void atomic_int_store(int *p, int v) { + atomic_store_explicit((atomic_int *)p, v, memory_order_release); + } + #endif + + """ + cdef int _cyb_atomic_int_load "atomic_int_load"(int *p) nogil + cdef void _cyb_atomic_int_store "atomic_int_store"(int *p, int v) nogil + cdef extern from "": void* _cyb_dlsym "dlsym"(void*, const char*) nogil const void * _cyb_RTLD_DEFAULT "RTLD_DEFAULT" @@ -17,7 +49,7 @@ from libc.stdint cimport intptr_t as _cyb_intptr_t import threading as _cyb_threading -cdef bint _cyb___py_cufile_init = False +cdef int _cyb___py_cufile_init = 0 cdef dict _cyb_func_ptrs = None cdef object _cyb_symbol_lock = _cyb_threading.Lock() @@ -289,11 +321,11 @@ cdef int _init_cufile() except -1 nogil: handle = load_library() __cuFileSetParameterString = _cyb_dlsym(handle, 'cuFileSetParameterString') - _cyb___py_cufile_init = True + _cyb_atomic_int_store(&_cyb___py_cufile_init, 1) return 0 cdef inline int _check_or_init_cufile() except -1 nogil: - if _cyb___py_cufile_init: + if _cyb_atomic_int_load(&_cyb___py_cufile_init): return 0 return _init_cufile() diff --git a/cuda_bindings/cuda/bindings/_internal/driver_linux.pyx b/cuda_bindings/cuda/bindings/_internal/driver_linux.pyx index ba774095675..e10852013ea 100644 --- a/cuda_bindings/cuda/bindings/_internal/driver_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/driver_linux.pyx @@ -3,11 +3,43 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated with version 12.9.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=ee0d1bcca022f6bf920320a877e2441f3548016a7cbad6d48ed95aebc70cea2e +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=f37bf970f8f822c8b606546584bdfde2530c1e2cd8aa36a359b8b960aff79186 # <<<< PREAMBLE CONTENT >>>> +cdef extern from * nogil: + """ + #if defined(_MSC_VER) && !defined(__clang__) + #include + static __forceinline int atomic_int_load(int *p) { + int v = *(int volatile *)p; _ReadBarrier(); return v; + } + static __forceinline void atomic_int_store(int *p, int v) { + _WriteBarrier(); *(int volatile *)p = v; + } + #elif defined(__cplusplus) + /* GCC/Clang __atomic builtins work in any C++ standard without headers */ + static inline int atomic_int_load(int *p) { + return __atomic_load_n(p, __ATOMIC_ACQUIRE); + } + static inline void atomic_int_store(int *p, int v) { + __atomic_store_n(p, v, __ATOMIC_RELEASE); + } + #else + #include + static inline int atomic_int_load(int *p) { + return (int)atomic_load_explicit((atomic_int *)p, memory_order_acquire); + } + static inline void atomic_int_store(int *p, int v) { + atomic_store_explicit((atomic_int *)p, v, memory_order_release); + } + #endif + + """ + cdef int _cyb_atomic_int_load "atomic_int_load"(int *p) nogil + cdef void _cyb_atomic_int_store "atomic_int_store"(int *p, int v) nogil + cdef extern from "": void* _cyb_dlsym "dlsym"(void*, const char*) nogil @@ -18,7 +50,7 @@ import threading as _cyb_threading ctypedef int (*_cyb_cuGetProcAddress_v2_T)(const char *, void **, int, cuuint64_t, CUdriverProcAddressQueryResult *)except?CUDA_ERROR_NOT_FOUND nogil -cdef bint _cyb___py_driver_init = False +cdef int _cyb___py_driver_init = 0 cdef dict _cyb_func_ptrs = None cdef object _cyb_symbol_lock = _cyb_threading.Lock() @@ -1987,11 +2019,11 @@ cdef int _init_driver() except -1 nogil: global __cuGraphicsVDPAURegisterOutputSurface cuGetProcAddress_v2('cuGraphicsVDPAURegisterOutputSurface', &__cuGraphicsVDPAURegisterOutputSurface, 3010, ptds_mode, NULL) - _cyb___py_driver_init = True + _cyb_atomic_int_store(&_cyb___py_driver_init, 1) return 0 cdef inline int _check_or_init_driver() except -1 nogil: - if _cyb___py_driver_init: + if _cyb_atomic_int_load(&_cyb___py_driver_init): return 0 return _init_driver() diff --git a/cuda_bindings/cuda/bindings/_internal/driver_windows.pyx b/cuda_bindings/cuda/bindings/_internal/driver_windows.pyx index a3ee8f30625..6fa8c56e8af 100644 --- a/cuda_bindings/cuda/bindings/_internal/driver_windows.pyx +++ b/cuda_bindings/cuda/bindings/_internal/driver_windows.pyx @@ -3,11 +3,43 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated with version 12.9.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=5748bf3321e7720f794cdbace9342c322bfbdfe48eb66758556a9ca55f0f2c89 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=b101459d496c90e392500d4a36a0b5d567ad8097b4a8f727af2177ac6c6e1dd3 # <<<< PREAMBLE CONTENT >>>> +cdef extern from * nogil: + """ + #if defined(_MSC_VER) && !defined(__clang__) + #include + static __forceinline int atomic_int_load(int *p) { + int v = *(int volatile *)p; _ReadBarrier(); return v; + } + static __forceinline void atomic_int_store(int *p, int v) { + _WriteBarrier(); *(int volatile *)p = v; + } + #elif defined(__cplusplus) + /* GCC/Clang __atomic builtins work in any C++ standard without headers */ + static inline int atomic_int_load(int *p) { + return __atomic_load_n(p, __ATOMIC_ACQUIRE); + } + static inline void atomic_int_store(int *p, int v) { + __atomic_store_n(p, v, __ATOMIC_RELEASE); + } + #else + #include + static inline int atomic_int_load(int *p) { + return (int)atomic_load_explicit((atomic_int *)p, memory_order_acquire); + } + static inline void atomic_int_store(int *p, int v) { + atomic_store_explicit((atomic_int *)p, v, memory_order_release); + } + #endif + + """ + cdef int _cyb_atomic_int_load "atomic_int_load"(int *p) nogil + cdef void _cyb_atomic_int_store "atomic_int_store"(int *p, int v) nogil + cdef extern from "": ctypedef void* HMODULE void* _cyb_GetProcAddress "GetProcAddress"(HMODULE, const char*) nogil @@ -19,7 +51,7 @@ import threading as _cyb_threading ctypedef int (*_cyb_cuGetProcAddress_v2_T)(const char *, void **, int, cuuint64_t, CUdriverProcAddressQueryResult *)except?CUDA_ERROR_NOT_FOUND nogil -cdef bint _cyb___py_driver_init = False +cdef int _cyb___py_driver_init = 0 cdef dict _cyb_func_ptrs = None cdef object _cyb_symbol_lock = _cyb_threading.Lock() @@ -1990,11 +2022,11 @@ cdef int _init_driver() except -1 nogil: global __cuGraphicsVDPAURegisterOutputSurface cuGetProcAddress_v2('cuGraphicsVDPAURegisterOutputSurface', &__cuGraphicsVDPAURegisterOutputSurface, 3010, ptds_mode, NULL) - _cyb___py_driver_init = True + _cyb_atomic_int_store(&_cyb___py_driver_init, 1) return 0 cdef inline int _check_or_init_driver() except -1 nogil: - if _cyb___py_driver_init: + if _cyb_atomic_int_load(&_cyb___py_driver_init): return 0 return _init_driver() diff --git a/cuda_bindings/cuda/bindings/_internal/nvfatbin_linux.pyx b/cuda_bindings/cuda/bindings/_internal/nvfatbin_linux.pyx index 8cdec7065b3..01881a519b5 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvfatbin_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvfatbin_linux.pyx @@ -3,11 +3,43 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.4.1 to 13.3.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=8a025fac12ad4fa9dc651c68c1ab7948f78cbb4b9450935db8f930c9d44988f4 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=f86a7f7527aad594d7b2e67742165454729ecca3810c00e6786f772099b17850 # <<<< PREAMBLE CONTENT >>>> +cdef extern from * nogil: + """ + #if defined(_MSC_VER) && !defined(__clang__) + #include + static __forceinline int atomic_int_load(int *p) { + int v = *(int volatile *)p; _ReadBarrier(); return v; + } + static __forceinline void atomic_int_store(int *p, int v) { + _WriteBarrier(); *(int volatile *)p = v; + } + #elif defined(__cplusplus) + /* GCC/Clang __atomic builtins work in any C++ standard without headers */ + static inline int atomic_int_load(int *p) { + return __atomic_load_n(p, __ATOMIC_ACQUIRE); + } + static inline void atomic_int_store(int *p, int v) { + __atomic_store_n(p, v, __ATOMIC_RELEASE); + } + #else + #include + static inline int atomic_int_load(int *p) { + return (int)atomic_load_explicit((atomic_int *)p, memory_order_acquire); + } + static inline void atomic_int_store(int *p, int v) { + atomic_store_explicit((atomic_int *)p, v, memory_order_release); + } + #endif + + """ + cdef int _cyb_atomic_int_load "atomic_int_load"(int *p) nogil + cdef void _cyb_atomic_int_store "atomic_int_store"(int *p, int v) nogil + cdef extern from "": void* _cyb_dlsym "dlsym"(void*, const char*) nogil const void * _cyb_RTLD_DEFAULT "RTLD_DEFAULT" @@ -16,7 +48,7 @@ from libc.stdint cimport intptr_t as _cyb_intptr_t import threading as _cyb_threading -cdef bint _cyb___py_nvfatbin_init = False +cdef int _cyb___py_nvfatbin_init = 0 cdef dict _cyb_func_ptrs = None cdef object _cyb_symbol_lock = _cyb_threading.Lock() @@ -135,11 +167,11 @@ cdef int _init_nvfatbin() except -1 nogil: handle = load_library() __nvFatbinAddTileIR = _cyb_dlsym(handle, 'nvFatbinAddTileIR') - _cyb___py_nvfatbin_init = True + _cyb_atomic_int_store(&_cyb___py_nvfatbin_init, 1) return 0 cdef inline int _check_or_init_nvfatbin() except -1 nogil: - if _cyb___py_nvfatbin_init: + if _cyb_atomic_int_load(&_cyb___py_nvfatbin_init): return 0 return _init_nvfatbin() diff --git a/cuda_bindings/cuda/bindings/_internal/nvfatbin_windows.pyx b/cuda_bindings/cuda/bindings/_internal/nvfatbin_windows.pyx index c9bb82113cb..69d1417e8b5 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvfatbin_windows.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvfatbin_windows.pyx @@ -3,11 +3,43 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.4.1 to 13.3.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=c44272bf506dcc20b5771a20fb6efc77f920c9b9bb21a89b53e3a9e7d69ce1ef +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=3b89f4c5e0a102d65950a485dab14517cb67887864d22152311d76341701e667 # <<<< PREAMBLE CONTENT >>>> +cdef extern from * nogil: + """ + #if defined(_MSC_VER) && !defined(__clang__) + #include + static __forceinline int atomic_int_load(int *p) { + int v = *(int volatile *)p; _ReadBarrier(); return v; + } + static __forceinline void atomic_int_store(int *p, int v) { + _WriteBarrier(); *(int volatile *)p = v; + } + #elif defined(__cplusplus) + /* GCC/Clang __atomic builtins work in any C++ standard without headers */ + static inline int atomic_int_load(int *p) { + return __atomic_load_n(p, __ATOMIC_ACQUIRE); + } + static inline void atomic_int_store(int *p, int v) { + __atomic_store_n(p, v, __ATOMIC_RELEASE); + } + #else + #include + static inline int atomic_int_load(int *p) { + return (int)atomic_load_explicit((atomic_int *)p, memory_order_acquire); + } + static inline void atomic_int_store(int *p, int v) { + atomic_store_explicit((atomic_int *)p, v, memory_order_release); + } + #endif + + """ + cdef int _cyb_atomic_int_load "atomic_int_load"(int *p) nogil + cdef void _cyb_atomic_int_store "atomic_int_store"(int *p, int v) nogil + cdef extern from "": ctypedef void* HMODULE void* _cyb_GetProcAddress "GetProcAddress"(HMODULE, const char*) nogil @@ -16,7 +48,7 @@ from libc.stdint cimport intptr_t as _cyb_intptr_t import threading as _cyb_threading -cdef bint _cyb___py_nvfatbin_init = False +cdef int _cyb___py_nvfatbin_init = 0 cdef dict _cyb_func_ptrs = None cdef object _cyb_symbol_lock = _cyb_threading.Lock() @@ -87,11 +119,11 @@ cdef int _init_nvfatbin() except -1 nogil: global __nvFatbinAddTileIR __nvFatbinAddTileIR = _cyb_GetProcAddress(handle, 'nvFatbinAddTileIR') - _cyb___py_nvfatbin_init = True + _cyb_atomic_int_store(&_cyb___py_nvfatbin_init, 1) return 0 cdef inline int _check_or_init_nvfatbin() except -1 nogil: - if _cyb___py_nvfatbin_init: + if _cyb_atomic_int_load(&_cyb___py_nvfatbin_init): return 0 return _init_nvfatbin() diff --git a/cuda_bindings/cuda/bindings/_internal/nvjitlink_linux.pyx b/cuda_bindings/cuda/bindings/_internal/nvjitlink_linux.pyx index 2ff4282e6c4..6c515c54d0f 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvjitlink_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvjitlink_linux.pyx @@ -3,11 +3,43 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.0.1 to 13.3.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=2a8907b5ab8df8ecb19b6d0fd3014dea67a9e76e7a2a0ee81fdf23f449402dd6 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=11665992d7c94100ae00600171ac56e9e99ee0c2c43c1cb720b4df27602ca829 # <<<< PREAMBLE CONTENT >>>> +cdef extern from * nogil: + """ + #if defined(_MSC_VER) && !defined(__clang__) + #include + static __forceinline int atomic_int_load(int *p) { + int v = *(int volatile *)p; _ReadBarrier(); return v; + } + static __forceinline void atomic_int_store(int *p, int v) { + _WriteBarrier(); *(int volatile *)p = v; + } + #elif defined(__cplusplus) + /* GCC/Clang __atomic builtins work in any C++ standard without headers */ + static inline int atomic_int_load(int *p) { + return __atomic_load_n(p, __ATOMIC_ACQUIRE); + } + static inline void atomic_int_store(int *p, int v) { + __atomic_store_n(p, v, __ATOMIC_RELEASE); + } + #else + #include + static inline int atomic_int_load(int *p) { + return (int)atomic_load_explicit((atomic_int *)p, memory_order_acquire); + } + static inline void atomic_int_store(int *p, int v) { + atomic_store_explicit((atomic_int *)p, v, memory_order_release); + } + #endif + + """ + cdef int _cyb_atomic_int_load "atomic_int_load"(int *p) nogil + cdef void _cyb_atomic_int_store "atomic_int_store"(int *p, int v) nogil + cdef extern from "": void* _cyb_dlsym "dlsym"(void*, const char*) nogil const void * _cyb_RTLD_DEFAULT "RTLD_DEFAULT" @@ -16,7 +48,7 @@ from libc.stdint cimport intptr_t as _cyb_intptr_t import threading as _cyb_threading -cdef bint _cyb___py_nvjitlink_init = False +cdef int _cyb___py_nvjitlink_init = 0 cdef dict _cyb_func_ptrs = None cdef object _cyb_symbol_lock = _cyb_threading.Lock() @@ -167,11 +199,11 @@ cdef int _init_nvjitlink() except -1 nogil: handle = load_library() __nvJitLinkGetLinkedLTOIR = _cyb_dlsym(handle, 'nvJitLinkGetLinkedLTOIR') - _cyb___py_nvjitlink_init = True + _cyb_atomic_int_store(&_cyb___py_nvjitlink_init, 1) return 0 cdef inline int _check_or_init_nvjitlink() except -1 nogil: - if _cyb___py_nvjitlink_init: + if _cyb_atomic_int_load(&_cyb___py_nvjitlink_init): return 0 return _init_nvjitlink() diff --git a/cuda_bindings/cuda/bindings/_internal/nvjitlink_windows.pyx b/cuda_bindings/cuda/bindings/_internal/nvjitlink_windows.pyx index 680038584a7..6c2ccbd0671 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvjitlink_windows.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvjitlink_windows.pyx @@ -3,11 +3,43 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.0.1 to 13.3.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=8f99393554faa677ab0ab8326185997a183259db6b26b55561ed2ab6250201a6 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=72ad04bbd206b13b7c53a4530a55f9c84369e5fcf1599164b18546e2176f16f8 # <<<< PREAMBLE CONTENT >>>> +cdef extern from * nogil: + """ + #if defined(_MSC_VER) && !defined(__clang__) + #include + static __forceinline int atomic_int_load(int *p) { + int v = *(int volatile *)p; _ReadBarrier(); return v; + } + static __forceinline void atomic_int_store(int *p, int v) { + _WriteBarrier(); *(int volatile *)p = v; + } + #elif defined(__cplusplus) + /* GCC/Clang __atomic builtins work in any C++ standard without headers */ + static inline int atomic_int_load(int *p) { + return __atomic_load_n(p, __ATOMIC_ACQUIRE); + } + static inline void atomic_int_store(int *p, int v) { + __atomic_store_n(p, v, __ATOMIC_RELEASE); + } + #else + #include + static inline int atomic_int_load(int *p) { + return (int)atomic_load_explicit((atomic_int *)p, memory_order_acquire); + } + static inline void atomic_int_store(int *p, int v) { + atomic_store_explicit((atomic_int *)p, v, memory_order_release); + } + #endif + + """ + cdef int _cyb_atomic_int_load "atomic_int_load"(int *p) nogil + cdef void _cyb_atomic_int_store "atomic_int_store"(int *p, int v) nogil + cdef extern from "": ctypedef void* HMODULE void* _cyb_GetProcAddress "GetProcAddress"(HMODULE, const char*) nogil @@ -16,7 +48,7 @@ from libc.stdint cimport intptr_t as _cyb_intptr_t import threading as _cyb_threading -cdef bint _cyb___py_nvjitlink_init = False +cdef int _cyb___py_nvjitlink_init = 0 cdef dict _cyb_func_ptrs = None cdef object _cyb_symbol_lock = _cyb_threading.Lock() @@ -103,11 +135,11 @@ cdef int _init_nvjitlink() except -1 nogil: global __nvJitLinkGetLinkedLTOIR __nvJitLinkGetLinkedLTOIR = _cyb_GetProcAddress(handle, 'nvJitLinkGetLinkedLTOIR') - _cyb___py_nvjitlink_init = True + _cyb_atomic_int_store(&_cyb___py_nvjitlink_init, 1) return 0 cdef inline int _check_or_init_nvjitlink() except -1 nogil: - if _cyb___py_nvjitlink_init: + if _cyb_atomic_int_load(&_cyb___py_nvjitlink_init): return 0 return _init_nvjitlink() diff --git a/cuda_bindings/cuda/bindings/_internal/nvml_linux.pyx b/cuda_bindings/cuda/bindings/_internal/nvml_linux.pyx index 2cff506e87c..d2882b251b0 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvml_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvml_linux.pyx @@ -3,11 +3,43 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.1 to 13.3.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=27eba7e4fbbc2bca4f40e906d63b9386cce38cbabfcc50e6a2d7ad5bc0b68e91 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=646d902675de6987cff08e5702d3b2bff889e6a827273e57413aa5de45a5897a # <<<< PREAMBLE CONTENT >>>> +cdef extern from * nogil: + """ + #if defined(_MSC_VER) && !defined(__clang__) + #include + static __forceinline int atomic_int_load(int *p) { + int v = *(int volatile *)p; _ReadBarrier(); return v; + } + static __forceinline void atomic_int_store(int *p, int v) { + _WriteBarrier(); *(int volatile *)p = v; + } + #elif defined(__cplusplus) + /* GCC/Clang __atomic builtins work in any C++ standard without headers */ + static inline int atomic_int_load(int *p) { + return __atomic_load_n(p, __ATOMIC_ACQUIRE); + } + static inline void atomic_int_store(int *p, int v) { + __atomic_store_n(p, v, __ATOMIC_RELEASE); + } + #else + #include + static inline int atomic_int_load(int *p) { + return (int)atomic_load_explicit((atomic_int *)p, memory_order_acquire); + } + static inline void atomic_int_store(int *p, int v) { + atomic_store_explicit((atomic_int *)p, v, memory_order_release); + } + #endif + + """ + cdef int _cyb_atomic_int_load "atomic_int_load"(int *p) nogil + cdef void _cyb_atomic_int_store "atomic_int_store"(int *p, int v) nogil + cdef extern from "": void* _cyb_dlsym "dlsym"(void*, const char*) nogil const void * _cyb_RTLD_DEFAULT "RTLD_DEFAULT" @@ -16,7 +48,7 @@ from libc.stdint cimport intptr_t as _cyb_intptr_t import threading as _cyb_threading -cdef bint _cyb___py_nvml_init = False +cdef int _cyb___py_nvml_init = 0 cdef dict _cyb_func_ptrs = None cdef object _cyb_symbol_lock = _cyb_threading.Lock() @@ -2847,11 +2879,11 @@ cdef int _init_nvml() except -1 nogil: handle = load_library() __nvmlGpuInstanceSetVgpuSchedulerState_v2 = _cyb_dlsym(handle, 'nvmlGpuInstanceSetVgpuSchedulerState_v2') - _cyb___py_nvml_init = True + _cyb_atomic_int_store(&_cyb___py_nvml_init, 1) return 0 cdef inline int _check_or_init_nvml() except -1 nogil: - if _cyb___py_nvml_init: + if _cyb_atomic_int_load(&_cyb___py_nvml_init): return 0 return _init_nvml() diff --git a/cuda_bindings/cuda/bindings/_internal/nvml_windows.pyx b/cuda_bindings/cuda/bindings/_internal/nvml_windows.pyx index e0e38c1913e..f7ae66ae98e 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvml_windows.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvml_windows.pyx @@ -3,11 +3,43 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.9.1 to 13.3.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=71acdbf6d477ea00af29faeca397fad7352eec03aca08accffa76af57f2234f9 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=831330186c4a7bb029b953be6dd3cda119a7f10c56fa9378ab621fbc4374f9d1 # <<<< PREAMBLE CONTENT >>>> +cdef extern from * nogil: + """ + #if defined(_MSC_VER) && !defined(__clang__) + #include + static __forceinline int atomic_int_load(int *p) { + int v = *(int volatile *)p; _ReadBarrier(); return v; + } + static __forceinline void atomic_int_store(int *p, int v) { + _WriteBarrier(); *(int volatile *)p = v; + } + #elif defined(__cplusplus) + /* GCC/Clang __atomic builtins work in any C++ standard without headers */ + static inline int atomic_int_load(int *p) { + return __atomic_load_n(p, __ATOMIC_ACQUIRE); + } + static inline void atomic_int_store(int *p, int v) { + __atomic_store_n(p, v, __ATOMIC_RELEASE); + } + #else + #include + static inline int atomic_int_load(int *p) { + return (int)atomic_load_explicit((atomic_int *)p, memory_order_acquire); + } + static inline void atomic_int_store(int *p, int v) { + atomic_store_explicit((atomic_int *)p, v, memory_order_release); + } + #endif + + """ + cdef int _cyb_atomic_int_load "atomic_int_load"(int *p) nogil + cdef void _cyb_atomic_int_store "atomic_int_store"(int *p, int v) nogil + cdef extern from "": ctypedef void* HMODULE void* _cyb_GetProcAddress "GetProcAddress"(HMODULE, const char*) nogil @@ -16,7 +48,7 @@ from libc.stdint cimport intptr_t as _cyb_intptr_t import threading as _cyb_threading -cdef bint _cyb___py_nvml_init = False +cdef int _cyb___py_nvml_init = 0 cdef dict _cyb_func_ptrs = None cdef object _cyb_symbol_lock = _cyb_threading.Lock() @@ -1443,11 +1475,11 @@ cdef int _init_nvml() except -1 nogil: global __nvmlGpuInstanceSetVgpuSchedulerState_v2 __nvmlGpuInstanceSetVgpuSchedulerState_v2 = _cyb_GetProcAddress(handle, 'nvmlGpuInstanceSetVgpuSchedulerState_v2') - _cyb___py_nvml_init = True + _cyb_atomic_int_store(&_cyb___py_nvml_init, 1) return 0 cdef inline int _check_or_init_nvml() except -1 nogil: - if _cyb___py_nvml_init: + if _cyb_atomic_int_load(&_cyb___py_nvml_init): return 0 return _init_nvml() diff --git a/cuda_bindings/cuda/bindings/_internal/nvrtc_linux.pyx b/cuda_bindings/cuda/bindings/_internal/nvrtc_linux.pyx index c104cdc148f..30e91867341 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvrtc_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvrtc_linux.pyx @@ -3,11 +3,43 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated with version 12.9.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=e2e24347c1e80729bb672747acaee1b7248a8200f4a74cdbf968ae680a23d352 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=6853fa1859b4822144a4c2e8d564c365b091bfeb81ae1f0dbcb7266b197bae4e # <<<< PREAMBLE CONTENT >>>> +cdef extern from * nogil: + """ + #if defined(_MSC_VER) && !defined(__clang__) + #include + static __forceinline int atomic_int_load(int *p) { + int v = *(int volatile *)p; _ReadBarrier(); return v; + } + static __forceinline void atomic_int_store(int *p, int v) { + _WriteBarrier(); *(int volatile *)p = v; + } + #elif defined(__cplusplus) + /* GCC/Clang __atomic builtins work in any C++ standard without headers */ + static inline int atomic_int_load(int *p) { + return __atomic_load_n(p, __ATOMIC_ACQUIRE); + } + static inline void atomic_int_store(int *p, int v) { + __atomic_store_n(p, v, __ATOMIC_RELEASE); + } + #else + #include + static inline int atomic_int_load(int *p) { + return (int)atomic_load_explicit((atomic_int *)p, memory_order_acquire); + } + static inline void atomic_int_store(int *p, int v) { + atomic_store_explicit((atomic_int *)p, v, memory_order_release); + } + #endif + + """ + cdef int _cyb_atomic_int_load "atomic_int_load"(int *p) nogil + cdef void _cyb_atomic_int_store "atomic_int_store"(int *p, int v) nogil + cdef extern from "": void* _cyb_dlsym "dlsym"(void*, const char*) nogil const void * _cyb_RTLD_DEFAULT "RTLD_DEFAULT" @@ -16,7 +48,7 @@ from libc.stdint cimport intptr_t as _cyb_intptr_t import threading as _cyb_threading -cdef bint _cyb___py_nvrtc_init = False +cdef int _cyb___py_nvrtc_init = 0 cdef dict _cyb_func_ptrs = None cdef object _cyb_symbol_lock = _cyb_threading.Lock() @@ -231,11 +263,11 @@ cdef int _init_nvrtc() except -1 nogil: handle = load_library() __nvrtcSetFlowCallback = _cyb_dlsym(handle, 'nvrtcSetFlowCallback') - _cyb___py_nvrtc_init = True + _cyb_atomic_int_store(&_cyb___py_nvrtc_init, 1) return 0 cdef inline int _check_or_init_nvrtc() except -1 nogil: - if _cyb___py_nvrtc_init: + if _cyb_atomic_int_load(&_cyb___py_nvrtc_init): return 0 return _init_nvrtc() diff --git a/cuda_bindings/cuda/bindings/_internal/nvrtc_windows.pyx b/cuda_bindings/cuda/bindings/_internal/nvrtc_windows.pyx index 9d7747058ca..9473895c691 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvrtc_windows.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvrtc_windows.pyx @@ -3,11 +3,43 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated with version 12.9.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=53cf0d3710b141df164e10d1365f8f74781b4f338606aa9ea2481a027c25f519 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=f7bf76f469f683723715a85ab6db5d3b00ab94d04f3f789c5c6f2bc04e0c020f # <<<< PREAMBLE CONTENT >>>> +cdef extern from * nogil: + """ + #if defined(_MSC_VER) && !defined(__clang__) + #include + static __forceinline int atomic_int_load(int *p) { + int v = *(int volatile *)p; _ReadBarrier(); return v; + } + static __forceinline void atomic_int_store(int *p, int v) { + _WriteBarrier(); *(int volatile *)p = v; + } + #elif defined(__cplusplus) + /* GCC/Clang __atomic builtins work in any C++ standard without headers */ + static inline int atomic_int_load(int *p) { + return __atomic_load_n(p, __ATOMIC_ACQUIRE); + } + static inline void atomic_int_store(int *p, int v) { + __atomic_store_n(p, v, __ATOMIC_RELEASE); + } + #else + #include + static inline int atomic_int_load(int *p) { + return (int)atomic_load_explicit((atomic_int *)p, memory_order_acquire); + } + static inline void atomic_int_store(int *p, int v) { + atomic_store_explicit((atomic_int *)p, v, memory_order_release); + } + #endif + + """ + cdef int _cyb_atomic_int_load "atomic_int_load"(int *p) nogil + cdef void _cyb_atomic_int_store "atomic_int_store"(int *p, int v) nogil + cdef extern from "": ctypedef void* HMODULE void* _cyb_GetProcAddress "GetProcAddress"(HMODULE, const char*) nogil @@ -16,7 +48,7 @@ from libc.stdint cimport intptr_t as _cyb_intptr_t import threading as _cyb_threading -cdef bint _cyb___py_nvrtc_init = False +cdef int _cyb___py_nvrtc_init = 0 cdef dict _cyb_func_ptrs = None cdef object _cyb_symbol_lock = _cyb_threading.Lock() @@ -135,11 +167,11 @@ cdef int _init_nvrtc() except -1 nogil: global __nvrtcSetFlowCallback __nvrtcSetFlowCallback = _cyb_GetProcAddress(handle, 'nvrtcSetFlowCallback') - _cyb___py_nvrtc_init = True + _cyb_atomic_int_store(&_cyb___py_nvrtc_init, 1) return 0 cdef inline int _check_or_init_nvrtc() except -1 nogil: - if _cyb___py_nvrtc_init: + if _cyb_atomic_int_load(&_cyb___py_nvrtc_init): return 0 return _init_nvrtc() diff --git a/cuda_bindings/cuda/bindings/_internal/nvvm_linux.pyx b/cuda_bindings/cuda/bindings/_internal/nvvm_linux.pyx index 0aba7664f8b..d8b4271eb40 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvvm_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvvm_linux.pyx @@ -3,11 +3,43 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.0.1 to 13.3.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=786a789c534d0bdda803be738a4f76f2db47bf188708dac946b41aec6c6aa4a4 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=e0b66c45b6f66a7ab7bae49939a26007efef95651084f1ef09fd32848260f2c8 # <<<< PREAMBLE CONTENT >>>> +cdef extern from * nogil: + """ + #if defined(_MSC_VER) && !defined(__clang__) + #include + static __forceinline int atomic_int_load(int *p) { + int v = *(int volatile *)p; _ReadBarrier(); return v; + } + static __forceinline void atomic_int_store(int *p, int v) { + _WriteBarrier(); *(int volatile *)p = v; + } + #elif defined(__cplusplus) + /* GCC/Clang __atomic builtins work in any C++ standard without headers */ + static inline int atomic_int_load(int *p) { + return __atomic_load_n(p, __ATOMIC_ACQUIRE); + } + static inline void atomic_int_store(int *p, int v) { + __atomic_store_n(p, v, __ATOMIC_RELEASE); + } + #else + #include + static inline int atomic_int_load(int *p) { + return (int)atomic_load_explicit((atomic_int *)p, memory_order_acquire); + } + static inline void atomic_int_store(int *p, int v) { + atomic_store_explicit((atomic_int *)p, v, memory_order_release); + } + #endif + + """ + cdef int _cyb_atomic_int_load "atomic_int_load"(int *p) nogil + cdef void _cyb_atomic_int_store "atomic_int_store"(int *p, int v) nogil + cdef extern from "": void* _cyb_dlsym "dlsym"(void*, const char*) nogil const void * _cyb_RTLD_DEFAULT "RTLD_DEFAULT" @@ -16,7 +48,7 @@ from libc.stdint cimport intptr_t as _cyb_intptr_t import threading as _cyb_threading -cdef bint _cyb___py_nvvm_init = False +cdef int _cyb___py_nvvm_init = 0 cdef dict _cyb_func_ptrs = None cdef object _cyb_symbol_lock = _cyb_threading.Lock() @@ -151,11 +183,11 @@ cdef int _init_nvvm() except -1 nogil: handle = load_library() __nvvmLLVMVersion = _cyb_dlsym(handle, 'nvvmLLVMVersion') - _cyb___py_nvvm_init = True + _cyb_atomic_int_store(&_cyb___py_nvvm_init, 1) return 0 cdef inline int _check_or_init_nvvm() except -1 nogil: - if _cyb___py_nvvm_init: + if _cyb_atomic_int_load(&_cyb___py_nvvm_init): return 0 return _init_nvvm() diff --git a/cuda_bindings/cuda/bindings/_internal/nvvm_windows.pyx b/cuda_bindings/cuda/bindings/_internal/nvvm_windows.pyx index 72262266fac..31e23b6f792 100644 --- a/cuda_bindings/cuda/bindings/_internal/nvvm_windows.pyx +++ b/cuda_bindings/cuda/bindings/_internal/nvvm_windows.pyx @@ -3,11 +3,43 @@ # SPDX-License-Identifier: Apache-2.0 # # This code was automatically generated across versions from 12.0.1 to 13.3.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=cd105988425e21a30e32255acbc5654de835d0c09b5dd1c4598b09146fa590c5 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=19fa5b34915a71deea0e75c2a16830e9571463f9cc32aa8b233853c303d6d742 # <<<< PREAMBLE CONTENT >>>> +cdef extern from * nogil: + """ + #if defined(_MSC_VER) && !defined(__clang__) + #include + static __forceinline int atomic_int_load(int *p) { + int v = *(int volatile *)p; _ReadBarrier(); return v; + } + static __forceinline void atomic_int_store(int *p, int v) { + _WriteBarrier(); *(int volatile *)p = v; + } + #elif defined(__cplusplus) + /* GCC/Clang __atomic builtins work in any C++ standard without headers */ + static inline int atomic_int_load(int *p) { + return __atomic_load_n(p, __ATOMIC_ACQUIRE); + } + static inline void atomic_int_store(int *p, int v) { + __atomic_store_n(p, v, __ATOMIC_RELEASE); + } + #else + #include + static inline int atomic_int_load(int *p) { + return (int)atomic_load_explicit((atomic_int *)p, memory_order_acquire); + } + static inline void atomic_int_store(int *p, int v) { + atomic_store_explicit((atomic_int *)p, v, memory_order_release); + } + #endif + + """ + cdef int _cyb_atomic_int_load "atomic_int_load"(int *p) nogil + cdef void _cyb_atomic_int_store "atomic_int_store"(int *p, int v) nogil + cdef extern from "": ctypedef void* HMODULE void* _cyb_GetProcAddress "GetProcAddress"(HMODULE, const char*) nogil @@ -16,7 +48,7 @@ from libc.stdint cimport intptr_t as _cyb_intptr_t import threading as _cyb_threading -cdef bint _cyb___py_nvvm_init = False +cdef int _cyb___py_nvvm_init = 0 cdef dict _cyb_func_ptrs = None cdef object _cyb_symbol_lock = _cyb_threading.Lock() @@ -95,11 +127,11 @@ cdef int _init_nvvm() except -1 nogil: global __nvvmLLVMVersion __nvvmLLVMVersion = _cyb_GetProcAddress(handle, 'nvvmLLVMVersion') - _cyb___py_nvvm_init = True + _cyb_atomic_int_store(&_cyb___py_nvvm_init, 1) return 0 cdef inline int _check_or_init_nvvm() except -1 nogil: - if _cyb___py_nvvm_init: + if _cyb_atomic_int_load(&_cyb___py_nvvm_init): return 0 return _init_nvvm() diff --git a/cuda_bindings/cuda/bindings/cydriver.pxd b/cuda_bindings/cuda/bindings/cydriver.pxd index bb85992130c..232b59528ca 100644 --- a/cuda_bindings/cuda/bindings/cydriver.pxd +++ b/cuda_bindings/cuda/bindings/cydriver.pxd @@ -4,7 +4,7 @@ # # This code was automatically generated with version 12.9.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=357125e2d24ab45b6b2e9c8cba153d59a70f46a832f2fd54d141d227e34c9a5a +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=2ead489e46eaac7d4f700aeb29e160ce35593ce21ad8d399ebb827146046f4b0 from libc.stdint cimport uint32_t, uint64_t @@ -1274,16 +1274,16 @@ cdef extern from 'cuda.h': CU_COREDUMP_LIGHTWEIGHT_FLAGS cdef extern from 'cuda.h': - ctypedef enum CUgreenCtxCreate_flags: + ctypedef enum CUgreenCtxCreate_flags "CUgreenCtxCreate_flags": CU_GREEN_CTX_DEFAULT_STREAM cdef extern from 'cuda.h': - ctypedef enum CUdevSmResourceSplit_flags: + ctypedef enum CUdevSmResourceSplit_flags "CUdevSmResourceSplit_flags": CU_DEV_SM_RESOURCE_SPLIT_IGNORE_SM_COSCHEDULING CU_DEV_SM_RESOURCE_SPLIT_MAX_POTENTIAL_CLUSTER_SIZE cdef extern from 'cuda.h': - ctypedef enum CUdevResourceType: + ctypedef enum CUdevResourceType "CUdevResourceType": CU_DEV_RESOURCE_TYPE_INVALID CU_DEV_RESOURCE_TYPE_SM diff --git a/cuda_bindings/cuda/bindings/cynvrtc.pxd b/cuda_bindings/cuda/bindings/cynvrtc.pxd index 40223d9dea5..e71047109dc 100644 --- a/cuda_bindings/cuda/bindings/cynvrtc.pxd +++ b/cuda_bindings/cuda/bindings/cynvrtc.pxd @@ -4,13 +4,13 @@ # # This code was automatically generated with version 12.9.0. Do not modify it directly. -# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=a876b7bb229abd9176c5462de5820fba48af99c2a49a80601b7d47c85f7b5146 +# CYTHON-BINDINGS-GENERATED-DO-NOT-MODIFY-THIS-FILE: format=1; content-sha256=6f38dbbe253af1c7868b30481f9caa6a927ecff257c6d62a5b704fdbda0a07d5 from libc.stdint cimport uint32_t, uint64_t # ENUMS cdef extern from 'nvrtc.h': - ctypedef enum nvrtcResult: + ctypedef enum nvrtcResult "nvrtcResult": NVRTC_SUCCESS NVRTC_ERROR_OUT_OF_MEMORY NVRTC_ERROR_PROGRAM_CREATION_FAILURE