Merge branch '12.9.x' into bp_313t_314_314t

Author: leofang

cuda_bindings/cuda/bindings/_internal/cufile_linux.pyx

@@ -74,258 +74,246 @@ cdef void* __cuFileSetParameterString = NULL
 cdef void* __cuFileDriverClose = NULL
 
 
-cdef void* load_library(const int driver_ver) except* with gil:
+cdef void* load_library() except* with gil:
     cdef uintptr_t handle = load_nvidia_dynamic_lib("cufile")._handle_uint
     return <void*>handle
 
 
-cdef int _check_or_init_cufile() except -1 nogil:
+cdef int __check_or_init_cufile() except -1 nogil:
     global __py_cufile_init
-    if __py_cufile_init:
-        return 0
 
     cdef void* handle = NULL
-    cdef int err, driver_ver = 0
 
     with gil, __symbol_lock:
-        # Load driver to check version
-        handle = dlopen('libcuda.so.1', RTLD_NOW | RTLD_GLOBAL)
-        if handle == NULL:
-            err_msg = dlerror()
-            raise NotSupportedError(f'CUDA driver is not found ({err_msg.decode()})')
-        global __cuDriverGetVersion
-        if __cuDriverGetVersion == NULL:
-            __cuDriverGetVersion = dlsym(handle, "cuDriverGetVersion")
-        if __cuDriverGetVersion == NULL:
-            raise RuntimeError('something went wrong')
-        err = (<int (*)(int*) noexcept nogil>__cuDriverGetVersion)(&driver_ver)
-        if err != 0:
-            raise RuntimeError('something went wrong')
-        #dlclose(handle)
-        handle = NULL
-
         # Load function
         global __cuFileHandleRegister
         __cuFileHandleRegister = dlsym(RTLD_DEFAULT, 'cuFileHandleRegister')
         if __cuFileHandleRegister == NULL:
             if handle == NULL:
-                handle = load_library(driver_ver)
+                handle = load_library()
             __cuFileHandleRegister = dlsym(handle, 'cuFileHandleRegister')
 
         global __cuFileHandleDeregister
         __cuFileHandleDeregister = dlsym(RTLD_DEFAULT, 'cuFileHandleDeregister')
         if __cuFileHandleDeregister == NULL:
             if handle == NULL:
-                handle = load_library(driver_ver)
+                handle = load_library()
             __cuFileHandleDeregister = dlsym(handle, 'cuFileHandleDeregister')
 
         global __cuFileBufRegister
         __cuFileBufRegister = dlsym(RTLD_DEFAULT, 'cuFileBufRegister')
         if __cuFileBufRegister == NULL:
             if handle == NULL:
-                handle = load_library(driver_ver)
+                handle = load_library()
             __cuFileBufRegister = dlsym(handle, 'cuFileBufRegister')
 
         global __cuFileBufDeregister
         __cuFileBufDeregister = dlsym(RTLD_DEFAULT, 'cuFileBufDeregister')
         if __cuFileBufDeregister == NULL:
             if handle == NULL:
-                handle = load_library(driver_ver)
+                handle = load_library()
             __cuFileBufDeregister = dlsym(handle, 'cuFileBufDeregister')
 
         global __cuFileRead
         __cuFileRead = dlsym(RTLD_DEFAULT, 'cuFileRead')
         if __cuFileRead == NULL:
             if handle == NULL:
-                handle = load_library(driver_ver)
+                handle = load_library()
             __cuFileRead = dlsym(handle, 'cuFileRead')
 
         global __cuFileWrite
         __cuFileWrite = dlsym(RTLD_DEFAULT, 'cuFileWrite')
         if __cuFileWrite == NULL:
             if handle == NULL:
-                handle = load_library(driver_ver)
+                handle = load_library()
             __cuFileWrite = dlsym(handle, 'cuFileWrite')
 
         global __cuFileDriverOpen
         __cuFileDriverOpen = dlsym(RTLD_DEFAULT, 'cuFileDriverOpen')
         if __cuFileDriverOpen == NULL:
             if handle == NULL:
-                handle = load_library(driver_ver)
+                handle = load_library()
             __cuFileDriverOpen = dlsym(handle, 'cuFileDriverOpen')
 
         global __cuFileDriverClose_v2
         __cuFileDriverClose_v2 = dlsym(RTLD_DEFAULT, 'cuFileDriverClose_v2')
         if __cuFileDriverClose_v2 == NULL:
             if handle == NULL:
-                handle = load_library(driver_ver)
+                handle = load_library()
             __cuFileDriverClose_v2 = dlsym(handle, 'cuFileDriverClose_v2')
 
         global __cuFileUseCount
         __cuFileUseCount = dlsym(RTLD_DEFAULT, 'cuFileUseCount')
         if __cuFileUseCount == NULL:
             if handle == NULL:
-                handle = load_library(driver_ver)
+                handle = load_library()
             __cuFileUseCount = dlsym(handle, 'cuFileUseCount')
 
         global __cuFileDriverGetProperties
         __cuFileDriverGetProperties = dlsym(RTLD_DEFAULT, 'cuFileDriverGetProperties')
         if __cuFileDriverGetProperties == NULL:
             if handle == NULL:
-                handle = load_library(driver_ver)
+                handle = load_library()
             __cuFileDriverGetProperties = dlsym(handle, 'cuFileDriverGetProperties')
 
         global __cuFileDriverSetPollMode
         __cuFileDriverSetPollMode = dlsym(RTLD_DEFAULT, 'cuFileDriverSetPollMode')
         if __cuFileDriverSetPollMode == NULL:
             if handle == NULL:
-                handle = load_library(driver_ver)
+                handle = load_library()
             __cuFileDriverSetPollMode = dlsym(handle, 'cuFileDriverSetPollMode')
 
         global __cuFileDriverSetMaxDirectIOSize
         __cuFileDriverSetMaxDirectIOSize = dlsym(RTLD_DEFAULT, 'cuFileDriverSetMaxDirectIOSize')
         if __cuFileDriverSetMaxDirectIOSize == NULL:
             if handle == NULL:
-                handle = load_library(driver_ver)
+                handle = load_library()
             __cuFileDriverSetMaxDirectIOSize = dlsym(handle, 'cuFileDriverSetMaxDirectIOSize')
 
         global __cuFileDriverSetMaxCacheSize
         __cuFileDriverSetMaxCacheSize = dlsym(RTLD_DEFAULT, 'cuFileDriverSetMaxCacheSize')
         if __cuFileDriverSetMaxCacheSize == NULL:
             if handle == NULL:
-                handle = load_library(driver_ver)
+                handle = load_library()
             __cuFileDriverSetMaxCacheSize = dlsym(handle, 'cuFileDriverSetMaxCacheSize')
 
         global __cuFileDriverSetMaxPinnedMemSize
         __cuFileDriverSetMaxPinnedMemSize = dlsym(RTLD_DEFAULT, 'cuFileDriverSetMaxPinnedMemSize')
         if __cuFileDriverSetMaxPinnedMemSize == NULL:
             if handle == NULL:
-                handle = load_library(driver_ver)
+                handle = load_library()
             __cuFileDriverSetMaxPinnedMemSize = dlsym(handle, 'cuFileDriverSetMaxPinnedMemSize')
 
         global __cuFileBatchIOSetUp
         __cuFileBatchIOSetUp = dlsym(RTLD_DEFAULT, 'cuFileBatchIOSetUp')
         if __cuFileBatchIOSetUp == NULL:
             if handle == NULL:
-                handle = load_library(driver_ver)
+                handle = load_library()
             __cuFileBatchIOSetUp = dlsym(handle, 'cuFileBatchIOSetUp')
 
         global __cuFileBatchIOSubmit
         __cuFileBatchIOSubmit = dlsym(RTLD_DEFAULT, 'cuFileBatchIOSubmit')
         if __cuFileBatchIOSubmit == NULL:
             if handle == NULL:
-                handle = load_library(driver_ver)
+                handle = load_library()
             __cuFileBatchIOSubmit = dlsym(handle, 'cuFileBatchIOSubmit')
 
         global __cuFileBatchIOGetStatus
         __cuFileBatchIOGetStatus = dlsym(RTLD_DEFAULT, 'cuFileBatchIOGetStatus')
         if __cuFileBatchIOGetStatus == NULL:
             if handle == NULL:
-                handle = load_library(driver_ver)
+                handle = load_library()
             __cuFileBatchIOGetStatus = dlsym(handle, 'cuFileBatchIOGetStatus')
 
         global __cuFileBatchIOCancel
         __cuFileBatchIOCancel = dlsym(RTLD_DEFAULT, 'cuFileBatchIOCancel')
         if __cuFileBatchIOCancel == NULL:
             if handle == NULL:
-                handle = load_library(driver_ver)
+                handle = load_library()
             __cuFileBatchIOCancel = dlsym(handle, 'cuFileBatchIOCancel')
 
         global __cuFileBatchIODestroy
         __cuFileBatchIODestroy = dlsym(RTLD_DEFAULT, 'cuFileBatchIODestroy')
         if __cuFileBatchIODestroy == NULL:
             if handle == NULL:
-                handle = load_library(driver_ver)
+                handle = load_library()
             __cuFileBatchIODestroy = dlsym(handle, 'cuFileBatchIODestroy')
 
         global __cuFileReadAsync
         __cuFileReadAsync = dlsym(RTLD_DEFAULT, 'cuFileReadAsync')
         if __cuFileReadAsync == NULL:
             if handle == NULL:
-                handle = load_library(driver_ver)
+                handle = load_library()
             __cuFileReadAsync = dlsym(handle, 'cuFileReadAsync')
 
         global __cuFileWriteAsync
         __cuFileWriteAsync = dlsym(RTLD_DEFAULT, 'cuFileWriteAsync')
         if __cuFileWriteAsync == NULL:
             if handle == NULL:
-                handle = load_library(driver_ver)
+                handle = load_library()
             __cuFileWriteAsync = dlsym(handle, 'cuFileWriteAsync')
 
         global __cuFileStreamRegister
         __cuFileStreamRegister = dlsym(RTLD_DEFAULT, 'cuFileStreamRegister')
         if __cuFileStreamRegister == NULL:
             if handle == NULL:
-                handle = load_library(driver_ver)
+                handle = load_library()
             __cuFileStreamRegister = dlsym(handle, 'cuFileStreamRegister')
 
         global __cuFileStreamDeregister
         __cuFileStreamDeregister = dlsym(RTLD_DEFAULT, 'cuFileStreamDeregister')
         if __cuFileStreamDeregister == NULL:
             if handle == NULL:
-                handle = load_library(driver_ver)
+                handle = load_library()
             __cuFileStreamDeregister = dlsym(handle, 'cuFileStreamDeregister')
 
         global __cuFileGetVersion
         __cuFileGetVersion = dlsym(RTLD_DEFAULT, 'cuFileGetVersion')
         if __cuFileGetVersion == NULL:
             if handle == NULL:
-                handle = load_library(driver_ver)
+                handle = load_library()
             __cuFileGetVersion = dlsym(handle, 'cuFileGetVersion')
 
         global __cuFileGetParameterSizeT
         __cuFileGetParameterSizeT = dlsym(RTLD_DEFAULT, 'cuFileGetParameterSizeT')
         if __cuFileGetParameterSizeT == NULL:
             if handle == NULL:
-                handle = load_library(driver_ver)
+                handle = load_library()
             __cuFileGetParameterSizeT = dlsym(handle, 'cuFileGetParameterSizeT')
 
         global __cuFileGetParameterBool
         __cuFileGetParameterBool = dlsym(RTLD_DEFAULT, 'cuFileGetParameterBool')
         if __cuFileGetParameterBool == NULL:
             if handle == NULL:
-                handle = load_library(driver_ver)
+                handle = load_library()
             __cuFileGetParameterBool = dlsym(handle, 'cuFileGetParameterBool')
 
         global __cuFileGetParameterString
         __cuFileGetParameterString = dlsym(RTLD_DEFAULT, 'cuFileGetParameterString')
         if __cuFileGetParameterString == NULL:
             if handle == NULL:
-                handle = load_library(driver_ver)
+                handle = load_library()
             __cuFileGetParameterString = dlsym(handle, 'cuFileGetParameterString')
 
         global __cuFileSetParameterSizeT
         __cuFileSetParameterSizeT = dlsym(RTLD_DEFAULT, 'cuFileSetParameterSizeT')
         if __cuFileSetParameterSizeT == NULL:
             if handle == NULL:
-                handle = load_library(driver_ver)
+                handle = load_library()
             __cuFileSetParameterSizeT = dlsym(handle, 'cuFileSetParameterSizeT')
 
         global __cuFileSetParameterBool
         __cuFileSetParameterBool = dlsym(RTLD_DEFAULT, 'cuFileSetParameterBool')
         if __cuFileSetParameterBool == NULL:
             if handle == NULL:
-                handle = load_library(driver_ver)
+                handle = load_library()
             __cuFileSetParameterBool = dlsym(handle, 'cuFileSetParameterBool')
 
         global __cuFileSetParameterString
         __cuFileSetParameterString = dlsym(RTLD_DEFAULT, 'cuFileSetParameterString')
         if __cuFileSetParameterString == NULL:
             if handle == NULL:
-                handle = load_library(driver_ver)
+                handle = load_library()
             __cuFileSetParameterString = dlsym(handle, 'cuFileSetParameterString')
 
         global __cuFileDriverClose
         __cuFileDriverClose = dlsym(RTLD_DEFAULT, 'cuFileDriverClose')
         if __cuFileDriverClose == NULL:
             if handle == NULL:
-                handle = load_library(driver_ver)
+                handle = load_library()
             __cuFileDriverClose = dlsym(handle, 'cuFileDriverClose')
 
         __py_cufile_init = True
         return 0
 
 
+cdef inline int _check_or_init_cufile() except -1 nogil:
+    if __py_cufile_init:
+        return 0
+
+    return __check_or_init_cufile()
+
+
 cdef dict func_ptrs = None