From 9a774a8d574029122e85ce7df8e747465674f2d0 Mon Sep 17 00:00:00 2001 From: Nikshay Shrivastava Date: Mon, 29 Jun 2026 19:24:59 +0530 Subject: [PATCH 1/2] Add Windows arm64 discovery for cuDLA --- .../cuda/bindings/_internal/cudla.pxd | 2 +- .../cuda/bindings/_internal/cudla_linux.pyx | 2 +- .../cuda/bindings/_internal/cudla_windows.pyx | 348 ++++++++++++++++++ cuda_bindings/cuda/bindings/cudla.pxd | 2 +- cuda_bindings/cuda/bindings/cudla.pyx | 2 +- cuda_bindings/cuda/bindings/cycudla.pxd | 2 +- cuda_bindings/cuda/bindings/cycudla.pyx | 2 +- .../_dynamic_libs/descriptor_catalog.py | 6 + .../tests/test_load_nvidia_dynamic_lib.py | 12 +- 9 files changed, 368 insertions(+), 10 deletions(-) create mode 100644 cuda_bindings/cuda/bindings/_internal/cudla_windows.pyx diff --git a/cuda_bindings/cuda/bindings/_internal/cudla.pxd b/cuda_bindings/cuda/bindings/_internal/cudla.pxd index e4c479673de..384692eb696 100644 --- a/cuda_bindings/cuda/bindings/_internal/cudla.pxd +++ b/cuda_bindings/cuda/bindings/_internal/cudla.pxd @@ -1,7 +1,7 @@ # SPDX-FileCopyrightText: Copyright (c) 2024-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE -# This code was automatically generated across versions from 1.5.0 to 13.3.0, generator version 0.3.1.dev1719+g565f73f4e. Do not modify it directly. +# This code was automatically generated across versions from 1.5.0 to 13.3.0, generator version 0.3.1.dev1465+gc5c5c8652. Do not modify it directly. from ..cycudla cimport * diff --git a/cuda_bindings/cuda/bindings/_internal/cudla_linux.pyx b/cuda_bindings/cuda/bindings/_internal/cudla_linux.pyx index 2d760477718..e8903e0ce29 100644 --- a/cuda_bindings/cuda/bindings/_internal/cudla_linux.pyx +++ b/cuda_bindings/cuda/bindings/_internal/cudla_linux.pyx @@ -1,7 +1,7 @@ # SPDX-FileCopyrightText: Copyright (c) 2024-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE -# This code was automatically generated across versions from 1.5.0 to 13.3.0, generator version 0.3.1.dev1719+g565f73f4e. Do not modify it directly. +# This code was automatically generated across versions from 1.5.0 to 13.3.0, generator version 0.3.1.dev1465+gc5c5c8652. Do not modify it directly. from libc.stdint cimport intptr_t, uintptr_t diff --git a/cuda_bindings/cuda/bindings/_internal/cudla_windows.pyx b/cuda_bindings/cuda/bindings/_internal/cudla_windows.pyx new file mode 100644 index 00000000000..0aeaba2ddea --- /dev/null +++ b/cuda_bindings/cuda/bindings/_internal/cudla_windows.pyx @@ -0,0 +1,348 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE + +# This code was automatically generated across versions from 1.5.0 to 13.3.0, generator version 0.3.1.dev1465+gc5c5c8652. Do not modify it directly. + +from libc.stdint cimport intptr_t + +import threading +from .utils import FunctionNotFoundError, NotSupportedError + +from cuda.pathfinder import load_nvidia_dynamic_lib + +from libc.stddef cimport wchar_t +from libc.stdint cimport uintptr_t +from cpython cimport PyUnicode_AsWideCharString, PyMem_Free + +# You must 'from .utils import NotSupportedError' before using this template + +cdef extern from "windows.h" nogil: + ctypedef void* HMODULE + ctypedef void* HANDLE + ctypedef void* FARPROC + ctypedef unsigned long DWORD + ctypedef const wchar_t *LPCWSTR + ctypedef const char *LPCSTR + + cdef DWORD LOAD_LIBRARY_SEARCH_SYSTEM32 = 0x00000800 + cdef DWORD LOAD_LIBRARY_SEARCH_DEFAULT_DIRS = 0x00001000 + cdef DWORD LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR = 0x00000100 + + HMODULE _LoadLibraryExW "LoadLibraryExW"( + LPCWSTR lpLibFileName, + HANDLE hFile, + DWORD dwFlags + ) + + FARPROC _GetProcAddress "GetProcAddress"(HMODULE hModule, LPCSTR lpProcName) + +cdef inline uintptr_t LoadLibraryExW(str path, HANDLE hFile, DWORD dwFlags): + cdef uintptr_t result + cdef wchar_t* wpath = PyUnicode_AsWideCharString(path, NULL) + with nogil: + result = _LoadLibraryExW( + wpath, + hFile, + dwFlags + ) + PyMem_Free(wpath) + return result + +cdef inline void *GetProcAddress(uintptr_t hModule, const char* lpProcName) nogil: + return _GetProcAddress(hModule, lpProcName) + +cdef int get_cuda_version(): + cdef int err, driver_ver = 0 + + # Load driver to check version + handle = LoadLibraryExW("nvcuda.dll", NULL, LOAD_LIBRARY_SEARCH_SYSTEM32) + if handle == 0: + raise NotSupportedError('CUDA driver is not found') + cuDriverGetVersion = GetProcAddress(handle, 'cuDriverGetVersion') + if cuDriverGetVersion == NULL: + raise RuntimeError('Did not find cuDriverGetVersion symbol in nvcuda.dll') + err = (cuDriverGetVersion)(&driver_ver) + if err != 0: + raise RuntimeError(f'cuDriverGetVersion returned error code {err}') + + return driver_ver + + + +############################################################################### +# Wrapper init +############################################################################### + +cdef object __symbol_lock = threading.Lock() +cdef bint __py_cudla_init = False + +cdef void* __cudlaGetVersion = NULL +cdef void* __cudlaDeviceGetCount = NULL +cdef void* __cudlaCreateDevice = NULL +cdef void* __cudlaMemRegister = NULL +cdef void* __cudlaModuleLoadFromMemory = NULL +cdef void* __cudlaModuleGetAttributes = NULL +cdef void* __cudlaModuleUnload = NULL +cdef void* __cudlaSubmitTask = NULL +cdef void* __cudlaDeviceGetAttribute = NULL +cdef void* __cudlaMemUnregister = NULL +cdef void* __cudlaGetLastError = NULL +cdef void* __cudlaDestroyDevice = NULL +cdef void* __cudlaSetTaskTimeoutInMs = NULL + + +cdef int _init_cudla() except -1 nogil: + global __py_cudla_init + + with gil, __symbol_lock: + # Recheck the flag after obtaining the locks + if __py_cudla_init: + return 0 + + # Load library + handle = load_nvidia_dynamic_lib("cudla")._handle_uint + + # Load function + global __cudlaGetVersion + __cudlaGetVersion = GetProcAddress(handle, 'cudlaGetVersion') + + global __cudlaDeviceGetCount + __cudlaDeviceGetCount = GetProcAddress(handle, 'cudlaDeviceGetCount') + + global __cudlaCreateDevice + __cudlaCreateDevice = GetProcAddress(handle, 'cudlaCreateDevice') + + global __cudlaMemRegister + __cudlaMemRegister = GetProcAddress(handle, 'cudlaMemRegister') + + global __cudlaModuleLoadFromMemory + __cudlaModuleLoadFromMemory = GetProcAddress(handle, 'cudlaModuleLoadFromMemory') + + global __cudlaModuleGetAttributes + __cudlaModuleGetAttributes = GetProcAddress(handle, 'cudlaModuleGetAttributes') + + global __cudlaModuleUnload + __cudlaModuleUnload = GetProcAddress(handle, 'cudlaModuleUnload') + + global __cudlaSubmitTask + __cudlaSubmitTask = GetProcAddress(handle, 'cudlaSubmitTask') + + global __cudlaDeviceGetAttribute + __cudlaDeviceGetAttribute = GetProcAddress(handle, 'cudlaDeviceGetAttribute') + + global __cudlaMemUnregister + __cudlaMemUnregister = GetProcAddress(handle, 'cudlaMemUnregister') + + global __cudlaGetLastError + __cudlaGetLastError = GetProcAddress(handle, 'cudlaGetLastError') + + global __cudlaDestroyDevice + __cudlaDestroyDevice = GetProcAddress(handle, 'cudlaDestroyDevice') + + global __cudlaSetTaskTimeoutInMs + __cudlaSetTaskTimeoutInMs = GetProcAddress(handle, 'cudlaSetTaskTimeoutInMs') + + __py_cudla_init = True + return 0 + + +cdef inline int _check_or_init_cudla() except -1 nogil: + if __py_cudla_init: + return 0 + + return _init_cudla() + + +cdef dict func_ptrs = None + + +cpdef dict _inspect_function_pointers(): + global func_ptrs + if func_ptrs is not None: + return func_ptrs + + _check_or_init_cudla() + cdef dict data = {} + + global __cudlaGetVersion + data["__cudlaGetVersion"] = __cudlaGetVersion + + global __cudlaDeviceGetCount + data["__cudlaDeviceGetCount"] = __cudlaDeviceGetCount + + global __cudlaCreateDevice + data["__cudlaCreateDevice"] = __cudlaCreateDevice + + global __cudlaMemRegister + data["__cudlaMemRegister"] = __cudlaMemRegister + + global __cudlaModuleLoadFromMemory + data["__cudlaModuleLoadFromMemory"] = __cudlaModuleLoadFromMemory + + global __cudlaModuleGetAttributes + data["__cudlaModuleGetAttributes"] = __cudlaModuleGetAttributes + + global __cudlaModuleUnload + data["__cudlaModuleUnload"] = __cudlaModuleUnload + + global __cudlaSubmitTask + data["__cudlaSubmitTask"] = __cudlaSubmitTask + + global __cudlaDeviceGetAttribute + data["__cudlaDeviceGetAttribute"] = __cudlaDeviceGetAttribute + + global __cudlaMemUnregister + data["__cudlaMemUnregister"] = __cudlaMemUnregister + + global __cudlaGetLastError + data["__cudlaGetLastError"] = __cudlaGetLastError + + global __cudlaDestroyDevice + data["__cudlaDestroyDevice"] = __cudlaDestroyDevice + + global __cudlaSetTaskTimeoutInMs + data["__cudlaSetTaskTimeoutInMs"] = __cudlaSetTaskTimeoutInMs + + func_ptrs = data + return data + + +cpdef _inspect_function_pointer(str name): + global func_ptrs + if func_ptrs is None: + func_ptrs = _inspect_function_pointers() + return func_ptrs[name] + + +############################################################################### +# Wrapper functions +############################################################################### + +cdef cudlaStatus _cudlaGetVersion(uint64_t* const version) except?_CUDLASTATUS_INTERNAL_LOADING_ERROR nogil: + global __cudlaGetVersion + _check_or_init_cudla() + if __cudlaGetVersion == NULL: + with gil: + raise FunctionNotFoundError("function cudlaGetVersion is not found") + return (__cudlaGetVersion)( + version) + + +cdef cudlaStatus _cudlaDeviceGetCount(uint64_t* const pNumDevices) except?_CUDLASTATUS_INTERNAL_LOADING_ERROR nogil: + global __cudlaDeviceGetCount + _check_or_init_cudla() + if __cudlaDeviceGetCount == NULL: + with gil: + raise FunctionNotFoundError("function cudlaDeviceGetCount is not found") + return (__cudlaDeviceGetCount)( + pNumDevices) + + +cdef cudlaStatus _cudlaCreateDevice(const uint64_t device, cudlaDevHandle* const devHandle, const uint32_t flags) except?_CUDLASTATUS_INTERNAL_LOADING_ERROR nogil: + global __cudlaCreateDevice + _check_or_init_cudla() + if __cudlaCreateDevice == NULL: + with gil: + raise FunctionNotFoundError("function cudlaCreateDevice is not found") + return (__cudlaCreateDevice)( + device, devHandle, flags) + + +cdef cudlaStatus _cudlaMemRegister(const cudlaDevHandle devHandle, const uint64_t* const ptr, const size_t size, uint64_t** const devPtr, const uint32_t flags) except?_CUDLASTATUS_INTERNAL_LOADING_ERROR nogil: + global __cudlaMemRegister + _check_or_init_cudla() + if __cudlaMemRegister == NULL: + with gil: + raise FunctionNotFoundError("function cudlaMemRegister is not found") + return (__cudlaMemRegister)( + devHandle, ptr, size, devPtr, flags) + + +cdef cudlaStatus _cudlaModuleLoadFromMemory(const cudlaDevHandle devHandle, const uint8_t* const pModule, const size_t moduleSize, cudlaModule* const hModule, const uint32_t flags) except?_CUDLASTATUS_INTERNAL_LOADING_ERROR nogil: + global __cudlaModuleLoadFromMemory + _check_or_init_cudla() + if __cudlaModuleLoadFromMemory == NULL: + with gil: + raise FunctionNotFoundError("function cudlaModuleLoadFromMemory is not found") + return (__cudlaModuleLoadFromMemory)( + devHandle, pModule, moduleSize, hModule, flags) + + +cdef cudlaStatus _cudlaModuleGetAttributes(const cudlaModule hModule, const cudlaModuleAttributeType attrType, cudlaModuleAttribute* const attribute) except?_CUDLASTATUS_INTERNAL_LOADING_ERROR nogil: + global __cudlaModuleGetAttributes + _check_or_init_cudla() + if __cudlaModuleGetAttributes == NULL: + with gil: + raise FunctionNotFoundError("function cudlaModuleGetAttributes is not found") + return (__cudlaModuleGetAttributes)( + hModule, attrType, attribute) + + +cdef cudlaStatus _cudlaModuleUnload(const cudlaModule hModule, const uint32_t flags) except?_CUDLASTATUS_INTERNAL_LOADING_ERROR nogil: + global __cudlaModuleUnload + _check_or_init_cudla() + if __cudlaModuleUnload == NULL: + with gil: + raise FunctionNotFoundError("function cudlaModuleUnload is not found") + return (__cudlaModuleUnload)( + hModule, flags) + + +cdef cudlaStatus _cudlaSubmitTask(const cudlaDevHandle devHandle, const cudlaTask* const ptrToTasks, const uint32_t numTasks, void* const stream, const uint32_t flags) except?_CUDLASTATUS_INTERNAL_LOADING_ERROR nogil: + global __cudlaSubmitTask + _check_or_init_cudla() + if __cudlaSubmitTask == NULL: + with gil: + raise FunctionNotFoundError("function cudlaSubmitTask is not found") + return (__cudlaSubmitTask)( + devHandle, ptrToTasks, numTasks, stream, flags) + + +cdef cudlaStatus _cudlaDeviceGetAttribute(const cudlaDevHandle devHandle, const cudlaDevAttributeType attrib, cudlaDevAttribute* const pAttribute) except?_CUDLASTATUS_INTERNAL_LOADING_ERROR nogil: + global __cudlaDeviceGetAttribute + _check_or_init_cudla() + if __cudlaDeviceGetAttribute == NULL: + with gil: + raise FunctionNotFoundError("function cudlaDeviceGetAttribute is not found") + return (__cudlaDeviceGetAttribute)( + devHandle, attrib, pAttribute) + + +cdef cudlaStatus _cudlaMemUnregister(const cudlaDevHandle devHandle, const uint64_t* const devPtr) except?_CUDLASTATUS_INTERNAL_LOADING_ERROR nogil: + global __cudlaMemUnregister + _check_or_init_cudla() + if __cudlaMemUnregister == NULL: + with gil: + raise FunctionNotFoundError("function cudlaMemUnregister is not found") + return (__cudlaMemUnregister)( + devHandle, devPtr) + + +cdef cudlaStatus _cudlaGetLastError(const cudlaDevHandle devHandle) except?_CUDLASTATUS_INTERNAL_LOADING_ERROR nogil: + global __cudlaGetLastError + _check_or_init_cudla() + if __cudlaGetLastError == NULL: + with gil: + raise FunctionNotFoundError("function cudlaGetLastError is not found") + return (__cudlaGetLastError)( + devHandle) + + +cdef cudlaStatus _cudlaDestroyDevice(const cudlaDevHandle devHandle) except?_CUDLASTATUS_INTERNAL_LOADING_ERROR nogil: + global __cudlaDestroyDevice + _check_or_init_cudla() + if __cudlaDestroyDevice == NULL: + with gil: + raise FunctionNotFoundError("function cudlaDestroyDevice is not found") + return (__cudlaDestroyDevice)( + devHandle) + + +cdef cudlaStatus _cudlaSetTaskTimeoutInMs(const cudlaDevHandle devHandle, const uint32_t timeout) except?_CUDLASTATUS_INTERNAL_LOADING_ERROR nogil: + global __cudlaSetTaskTimeoutInMs + _check_or_init_cudla() + if __cudlaSetTaskTimeoutInMs == NULL: + with gil: + raise FunctionNotFoundError("function cudlaSetTaskTimeoutInMs is not found") + return (__cudlaSetTaskTimeoutInMs)( + devHandle, timeout) diff --git a/cuda_bindings/cuda/bindings/cudla.pxd b/cuda_bindings/cuda/bindings/cudla.pxd index 894aacb7c54..37861dd0cdc 100644 --- a/cuda_bindings/cuda/bindings/cudla.pxd +++ b/cuda_bindings/cuda/bindings/cudla.pxd @@ -1,7 +1,7 @@ # SPDX-FileCopyrightText: Copyright (c) 2024-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE -# This code was automatically generated across versions from 1.5.0 to 13.3.0, generator version 0.3.1.dev1719+g565f73f4e. Do not modify it directly. +# This code was automatically generated across versions from 1.5.0 to 13.3.0, generator version 0.3.1.dev1465+gc5c5c8652. Do not modify it directly. from libc.stdint cimport intptr_t diff --git a/cuda_bindings/cuda/bindings/cudla.pyx b/cuda_bindings/cuda/bindings/cudla.pyx index f67bd54520d..1348bd236a2 100644 --- a/cuda_bindings/cuda/bindings/cudla.pyx +++ b/cuda_bindings/cuda/bindings/cudla.pyx @@ -1,7 +1,7 @@ # SPDX-FileCopyrightText: Copyright (c) 2024-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE -# This code was automatically generated across versions from 1.5.0 to 13.3.0, generator version 0.3.1.dev1752+g89e531539. Do not modify it directly. +# This code was automatically generated across versions from 1.5.0 to 13.3.0, generator version 0.3.1.dev1465+gc5c5c8652. Do not modify it directly. cimport cython # NOQA from libc.stdint cimport intptr_t, uintptr_t diff --git a/cuda_bindings/cuda/bindings/cycudla.pxd b/cuda_bindings/cuda/bindings/cycudla.pxd index b8fdec0a2f5..e21b2061b2a 100644 --- a/cuda_bindings/cuda/bindings/cycudla.pxd +++ b/cuda_bindings/cuda/bindings/cycudla.pxd @@ -1,7 +1,7 @@ # SPDX-FileCopyrightText: Copyright (c) 2024-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE -# This code was automatically generated across versions from 1.5.0 to 13.3.0, generator version 0.3.1.dev1719+g565f73f4e. Do not modify it directly. +# This code was automatically generated across versions from 1.5.0 to 13.3.0, generator version 0.3.1.dev1465+gc5c5c8652. Do not modify it directly. # This layer exposes the C header to Cython as-is. from libc.stdint cimport int8_t, int16_t, int32_t, int64_t diff --git a/cuda_bindings/cuda/bindings/cycudla.pyx b/cuda_bindings/cuda/bindings/cycudla.pyx index 543acf56fc3..78b2dee35c7 100644 --- a/cuda_bindings/cuda/bindings/cycudla.pyx +++ b/cuda_bindings/cuda/bindings/cycudla.pyx @@ -1,7 +1,7 @@ # SPDX-FileCopyrightText: Copyright (c) 2024-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE -# This code was automatically generated across versions from 1.5.0 to 13.3.0, generator version 0.3.1.dev1719+g565f73f4e. Do not modify it directly. +# This code was automatically generated across versions from 1.5.0 to 13.3.0, generator version 0.3.1.dev1465+gc5c5c8652. Do not modify it directly. from ._internal cimport cudla as _cudla diff --git a/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/descriptor_catalog.py b/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/descriptor_catalog.py index ba8ed82cdbb..f1ad8f72d81 100644 --- a/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/descriptor_catalog.py +++ b/cuda_pathfinder/cuda/pathfinder/_dynamic_libs/descriptor_catalog.py @@ -297,7 +297,13 @@ class DescriptorSpec: name="cudla", packaged_with="ctk", linux_sonames=("libcudla.so.1",), + windows_dlls=("cudla.dll",), site_packages_linux=("nvidia/cu13/lib",), + # No Windows pip wheel ships cudla.dll today; it is loaded from the local + # CUDA Toolkit only, so site_packages_windows is intentionally left empty. + # The Windows CUDA Toolkit ships cudla.dll under per-architecture bin + # subdirs (e.g. bin/arm64 on N1X); search those ahead of the defaults. + anchor_rel_dirs_windows=("bin/arm64", "bin/x64", "bin"), ), # ----------------------------------------------------------------------- # Third-party / separately packaged libraries diff --git a/cuda_pathfinder/tests/test_load_nvidia_dynamic_lib.py b/cuda_pathfinder/tests/test_load_nvidia_dynamic_lib.py index 401e7dc13f8..7a32aa46c0b 100644 --- a/cuda_pathfinder/tests/test_load_nvidia_dynamic_lib.py +++ b/cuda_pathfinder/tests/test_load_nvidia_dynamic_lib.py @@ -1,4 +1,4 @@ -# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 import os @@ -44,9 +44,13 @@ def test_supported_libnames_linux_site_packages_libdirs_ctk_consistency(): def test_supported_libnames_windows_site_packages_libdirs_ctk_consistency(): - assert tuple(sorted(supported_nvidia_libs.SUPPORTED_LIBNAMES_WINDOWS)) == tuple( - sorted(supported_nvidia_libs.SITE_PACKAGES_LIBDIRS_WINDOWS_CTK.keys()) - ) + # Not every Windows CTK library ships in a pip wheel (e.g. cudla is loaded + # from the local CUDA Toolkit only), so a library may legitimately omit + # site_packages_windows. Only assert that every site-packages entry maps to + # a supported Windows libname, not the other way around. + site_packages_libnames = set(supported_nvidia_libs.SITE_PACKAGES_LIBDIRS_WINDOWS_CTK.keys()) + supported_libnames = set(supported_nvidia_libs.SUPPORTED_LIBNAMES_WINDOWS) + assert site_packages_libnames <= supported_libnames, sorted(site_packages_libnames - supported_libnames) @pytest.mark.parametrize("dict_name", ["SUPPORTED_LINUX_SONAMES", "SUPPORTED_WINDOWS_DLLS"]) From 9ceeb2846d35ae03b629e7a84ba5ee45bc709101 Mon Sep 17 00:00:00 2001 From: Nikshay Shrivastava Date: Tue, 30 Jun 2026 22:32:05 +0530 Subject: [PATCH 2/2] Drop redundant assert message in cuDLA Windows consistency test --- cuda_pathfinder/tests/test_load_nvidia_dynamic_lib.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cuda_pathfinder/tests/test_load_nvidia_dynamic_lib.py b/cuda_pathfinder/tests/test_load_nvidia_dynamic_lib.py index 7a32aa46c0b..3e240dcf468 100644 --- a/cuda_pathfinder/tests/test_load_nvidia_dynamic_lib.py +++ b/cuda_pathfinder/tests/test_load_nvidia_dynamic_lib.py @@ -50,7 +50,7 @@ def test_supported_libnames_windows_site_packages_libdirs_ctk_consistency(): # a supported Windows libname, not the other way around. site_packages_libnames = set(supported_nvidia_libs.SITE_PACKAGES_LIBDIRS_WINDOWS_CTK.keys()) supported_libnames = set(supported_nvidia_libs.SUPPORTED_LIBNAMES_WINDOWS) - assert site_packages_libnames <= supported_libnames, sorted(site_packages_libnames - supported_libnames) + assert site_packages_libnames <= supported_libnames @pytest.mark.parametrize("dict_name", ["SUPPORTED_LINUX_SONAMES", "SUPPORTED_WINDOWS_DLLS"])