tensoracle 1.3.0__tar.gz → 1.4.0__tar.gz

{tensoracle-1.3.0 → tensoracle-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tensoracle
-Version: 1.3.0
+Version: 1.4.0
 Summary: Build, save, reuse, and execute TensorRT engines from safetensors weights
 Project-URL: documentation, https://sync-dev-org.github.io/tensoracle/
 Project-URL: repository, https://github.com/sync-dev-org/tensoracle
@@ -354,6 +354,26 @@ Neither cubin production nor native plugin building requires an OS-installed CUD
 
 The wheel also contains `tensoracle/cpp/include`, `tensoracle/cpp/src`, and `tensoracle/cpp/cmake`. Pass the installed `tensoracle/cpp` directory to CMake as `TENSORACLE_CPP_ROOT` and include `TensoracleCubinPlugin.cmake`. Its `tensoracle_add_cubin_plugin` function compiles the common C++ source, the caller's plugin source, and the generated `bundle.cpp` into the caller's library. The caller implements the graph's meaning, field meanings, weight placement, launch sequence, and variant selection. The common source owns typed fields in their original order, handles `IPluginV3` lifecycle methods, checks cubin digests and resources, loads one module per CUDA context, checks the generated argument count and specialization rules, appends the two supported zero scratch pointers, and launches kernels. The caller selects a variant using `Kernel::accepts` and derives the count passed to `Kernel::launch` from its argument array. The common source releases modules and device allocations in their owning contexts. The library must export TensorRT's `getCreators`; a static registration constructor is not supported.
 
+To record the CUDA inputs used by the plugin build, call `tensoracle_find_cuda` from `TensoracleCuda.cmake` (also included by `TensoracleCubinPlugin.cmake`):
+
+```cmake
+include("${TENSORACLE_CPP_ROOT}/cmake/TensoracleCuda.cmake")
+tensoracle_find_cuda(
+    OUT_INCLUDE_DIR cuda_include
+    OUT_DRIVER_LIBRARY cuda_driver)
+message(STATUS "CUDA headers: ${cuda_include}")
+message(STATUS "CUDA driver link library: ${cuda_driver}")
+```
+
+Both keywords are required and name variables set in the calling scope: `cuda_include` receives the directory containing `cuda.h`, and `cuda_driver` receives the driver link library's path. Unknown arguments are rejected. The function uses the same `CUDAToolkit_ROOT` CMake variable, environment variable, and default locations as `tensoracle_add_cubin_plugin`, and reports the same error when an input is missing. You can call it repeatedly, before or after adding the plugin.
+
+The function also makes the public IMPORTED target `tensoracle_cuda_driver` available. Link another CMake target to it to inherit the same include directory and driver library:
+
+```cmake
+add_library(cuda_consumer SHARED cuda_consumer.cpp)
+target_link_libraries(cuda_consumer PRIVATE tensoracle_cuda_driver)
+```
+
 `tensoracle::cubin::PluginBase` accepts a `PluginIO` declaration as its fourth constructor argument. `inputs` lists one `TensorSpec` per input in network order; each spec declares a TensorRT `type` and `format`. `output` declares the single output's type and format, and `shape_input_index` selects the input whose shape the output copies. For example, declare two fp16 / HWC8 inputs and one fp16 / HWC8 output with the shape of input 0:
 
 ```cpp
@@ -401,6 +421,16 @@ On 2026-10-18, the test suite and a native plugin build were run on Windows:
 
 On Windows, the standalone `cpp/` build and CTest passed, the CMake helper built the example plugin DLL against `nvinfer_11.lib`, and the plugin engine was built and reused in a separate process. The `py3-none-any` wheel built on Linux was installed unchanged on Windows. With `PATH` reduced to the Windows system directories and no CUDA or TensorRT SDK paths, the driver's `nvcuda.dll` and the pip-installed TensorRT runtime were sufficient to build and reuse engines.
 
+On 2026-10-27, `python/tests/test_example_plugin.py` was run on each GPU below with the example cubin bundle (digest `207d41310c87ae8b75b0301e881df881cdd2475eec07b82092e0ec66febbd5c0`). Each example wheel was built with TensorRT SDK `11.2.1.2` and tested with TensorRT runtime `11.4.0.106` (`tensorrt-cu13`). These runs cover one SDK/runtime pair per GPU, separately from the 25-pair matrix above. `inspect_wheel` confirmed that each wheel's library embeds cubins from this bundle.
+
+| GPU | Result | Python | OS / glibc / kernel / NVIDIA driver | CUDA toolkit (plugin build) |
+| --- | --- | --- | --- | --- |
+| NVIDIA RTX PRO 4000 Blackwell (sm120) | 7 passed, 0 failed, 0 skipped | 3.13.15 | WSL2 / glibc 2.43 / `6.18.54.1-microsoft-standard-WSL2` / 616.92 | 13.3 |
+| NVIDIA RTX 6000 Ada Generation (sm89) | 7 passed, 0 failed, 0 skipped | 3.13.15 | WSL2 / glibc 2.43 / `6.18.33.2-microsoft-standard-WSL2` / 596.72 | 13.2.86 |
+| NVIDIA RTX A6000 (sm86) | 7 passed, 0 failed, 0 skipped | 3.13.7 | WSL2 / glibc 2.39 / `6.18.54.1-microsoft-standard-WSL2` / 597.16 | 13.0.88 |
+
+The tests built and installed the example wheel in a temporary runtime environment, built and ran both plugins, reused a saved TensorRT engine in a separate process without calling the graph, selected a different engine cache entry when the plugin library changed, ran concurrently in two CUDA contexts, compared fp32 and TF32, and rejected a library embedding a different bundle.
+
 Native Linux, other kernels, Windows with sm86 or sm120, and TensorRT 11 versions not listed here have not been tested.
 
 ## Compare output arrays

{tensoracle-1.3.0 → tensoracle-1.4.0}/README.md

@@ -321,6 +321,26 @@ Neither cubin production nor native plugin building requires an OS-installed CUD
 
 The wheel also contains `tensoracle/cpp/include`, `tensoracle/cpp/src`, and `tensoracle/cpp/cmake`. Pass the installed `tensoracle/cpp` directory to CMake as `TENSORACLE_CPP_ROOT` and include `TensoracleCubinPlugin.cmake`. Its `tensoracle_add_cubin_plugin` function compiles the common C++ source, the caller's plugin source, and the generated `bundle.cpp` into the caller's library. The caller implements the graph's meaning, field meanings, weight placement, launch sequence, and variant selection. The common source owns typed fields in their original order, handles `IPluginV3` lifecycle methods, checks cubin digests and resources, loads one module per CUDA context, checks the generated argument count and specialization rules, appends the two supported zero scratch pointers, and launches kernels. The caller selects a variant using `Kernel::accepts` and derives the count passed to `Kernel::launch` from its argument array. The common source releases modules and device allocations in their owning contexts. The library must export TensorRT's `getCreators`; a static registration constructor is not supported.
 
+To record the CUDA inputs used by the plugin build, call `tensoracle_find_cuda` from `TensoracleCuda.cmake` (also included by `TensoracleCubinPlugin.cmake`):
+
+```cmake
+include("${TENSORACLE_CPP_ROOT}/cmake/TensoracleCuda.cmake")
+tensoracle_find_cuda(
+    OUT_INCLUDE_DIR cuda_include
+    OUT_DRIVER_LIBRARY cuda_driver)
+message(STATUS "CUDA headers: ${cuda_include}")
+message(STATUS "CUDA driver link library: ${cuda_driver}")
+```
+
+Both keywords are required and name variables set in the calling scope: `cuda_include` receives the directory containing `cuda.h`, and `cuda_driver` receives the driver link library's path. Unknown arguments are rejected. The function uses the same `CUDAToolkit_ROOT` CMake variable, environment variable, and default locations as `tensoracle_add_cubin_plugin`, and reports the same error when an input is missing. You can call it repeatedly, before or after adding the plugin.
+
+The function also makes the public IMPORTED target `tensoracle_cuda_driver` available. Link another CMake target to it to inherit the same include directory and driver library:
+
+```cmake
+add_library(cuda_consumer SHARED cuda_consumer.cpp)
+target_link_libraries(cuda_consumer PRIVATE tensoracle_cuda_driver)
+```
+
 `tensoracle::cubin::PluginBase` accepts a `PluginIO` declaration as its fourth constructor argument. `inputs` lists one `TensorSpec` per input in network order; each spec declares a TensorRT `type` and `format`. `output` declares the single output's type and format, and `shape_input_index` selects the input whose shape the output copies. For example, declare two fp16 / HWC8 inputs and one fp16 / HWC8 output with the shape of input 0:
 
 ```cpp
@@ -368,6 +388,16 @@ On 2026-10-18, the test suite and a native plugin build were run on Windows:
 
 On Windows, the standalone `cpp/` build and CTest passed, the CMake helper built the example plugin DLL against `nvinfer_11.lib`, and the plugin engine was built and reused in a separate process. The `py3-none-any` wheel built on Linux was installed unchanged on Windows. With `PATH` reduced to the Windows system directories and no CUDA or TensorRT SDK paths, the driver's `nvcuda.dll` and the pip-installed TensorRT runtime were sufficient to build and reuse engines.
 
+On 2026-10-27, `python/tests/test_example_plugin.py` was run on each GPU below with the example cubin bundle (digest `207d41310c87ae8b75b0301e881df881cdd2475eec07b82092e0ec66febbd5c0`). Each example wheel was built with TensorRT SDK `11.2.1.2` and tested with TensorRT runtime `11.4.0.106` (`tensorrt-cu13`). These runs cover one SDK/runtime pair per GPU, separately from the 25-pair matrix above. `inspect_wheel` confirmed that each wheel's library embeds cubins from this bundle.
+
+| GPU | Result | Python | OS / glibc / kernel / NVIDIA driver | CUDA toolkit (plugin build) |
+| --- | --- | --- | --- | --- |
+| NVIDIA RTX PRO 4000 Blackwell (sm120) | 7 passed, 0 failed, 0 skipped | 3.13.15 | WSL2 / glibc 2.43 / `6.18.54.1-microsoft-standard-WSL2` / 616.92 | 13.3 |
+| NVIDIA RTX 6000 Ada Generation (sm89) | 7 passed, 0 failed, 0 skipped | 3.13.15 | WSL2 / glibc 2.43 / `6.18.33.2-microsoft-standard-WSL2` / 596.72 | 13.2.86 |
+| NVIDIA RTX A6000 (sm86) | 7 passed, 0 failed, 0 skipped | 3.13.7 | WSL2 / glibc 2.39 / `6.18.54.1-microsoft-standard-WSL2` / 597.16 | 13.0.88 |
+
+The tests built and installed the example wheel in a temporary runtime environment, built and ran both plugins, reused a saved TensorRT engine in a separate process without calling the graph, selected a different engine cache entry when the plugin library changed, ran concurrently in two CUDA contexts, compared fp32 and TF32, and rejected a library embedding a different bundle.
+
 Native Linux, other kernels, Windows with sm86 or sm120, and TensorRT 11 versions not listed here have not been tested.
 
 ## Compare output arrays

{tensoracle-1.3.0 → tensoracle-1.4.0}/cpp/CMakeLists.txt

@@ -13,6 +13,10 @@ target_compile_features(tensoracle_cubin PUBLIC cxx_std_17)
 target_include_directories(tensoracle_cubin PUBLIC
     "${CMAKE_CURRENT_SOURCE_DIR}/include" "${TENSORRT_ROOT}/include")
 target_link_libraries(tensoracle_cubin PUBLIC tensoracle_internal_cuda_driver)
+if(NOT WIN32)
+    find_package(Threads REQUIRED)
+    target_link_libraries(tensoracle_cubin PUBLIC Threads::Threads)
+endif()
 target_compile_options(tensoracle_cubin PRIVATE
     $<$<CXX_COMPILER_ID:GNU,Clang>:-Wno-deprecated-declarations>)
 

{tensoracle-1.3.0 → tensoracle-1.4.0}/cpp/cmake/TensoracleCubinPlugin.cmake

@@ -30,6 +30,10 @@ function(tensoracle_add_cubin_plugin)
         "${_tensoracle_cpp}/include" "${TENSORACLE_NVINFER_INCLUDE}")
     target_link_libraries(${ARG_TARGET} PRIVATE
         "${TENSORACLE_NVINFER_LIBRARY}" tensoracle_internal_cuda_driver)
+    if(NOT WIN32)
+        find_package(Threads REQUIRED)
+        target_link_libraries(${ARG_TARGET} PRIVATE Threads::Threads)
+    endif()
     set_target_properties(${ARG_TARGET} PROPERTIES
         CXX_VISIBILITY_PRESET hidden VISIBILITY_INLINES_HIDDEN YES)
 endfunction()

{tensoracle-1.3.0 → tensoracle-1.4.0}/cpp/cmake/TensoracleCuda.cmake

@@ -91,5 +91,29 @@ function(_tensoracle_find_cuda)
         set_target_properties(tensoracle_internal_cuda_driver PROPERTIES
             IMPORTED_LOCATION "${_driver}" INTERFACE_INCLUDE_DIRECTORIES "${_include}")
     endif()
+    if(NOT TARGET tensoracle_cuda_driver)
+        add_library(tensoracle_cuda_driver ALIAS tensoracle_internal_cuda_driver)
+    endif()
     set(_tensoracle_cuda_root "${_root}" PARENT_SCOPE)
 endfunction()
+
+# Return the same CUDA inputs used by tensoracle_add_cubin_plugin and expose
+# tensoracle_cuda_driver for consumers that only need to link the Driver API.
+function(tensoracle_find_cuda)
+    cmake_parse_arguments(PARSE_ARGV 0 ARG "" "OUT_INCLUDE_DIR;OUT_DRIVER_LIBRARY" "")
+    if(DEFINED ARG_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "Unrecognized tensoracle_find_cuda arguments: ${ARG_UNPARSED_ARGUMENTS}")
+    endif()
+    if(ARG_KEYWORDS_MISSING_VALUES OR
+       NOT DEFINED ARG_OUT_INCLUDE_DIR OR "${ARG_OUT_INCLUDE_DIR}" STREQUAL "" OR
+       NOT DEFINED ARG_OUT_DRIVER_LIBRARY OR "${ARG_OUT_DRIVER_LIBRARY}" STREQUAL "")
+        message(FATAL_ERROR
+            "tensoracle_find_cuda requires OUT_INCLUDE_DIR and OUT_DRIVER_LIBRARY variable names")
+    endif()
+
+    _tensoracle_find_cuda()
+    get_target_property(_include tensoracle_cuda_driver INTERFACE_INCLUDE_DIRECTORIES)
+    get_target_property(_driver tensoracle_cuda_driver IMPORTED_LOCATION)
+    set("${ARG_OUT_INCLUDE_DIR}" "${_include}" PARENT_SCOPE)
+    set("${ARG_OUT_DRIVER_LIBRARY}" "${_driver}" PARENT_SCOPE)
+endfunction()

{tensoracle-1.3.0 → tensoracle-1.4.0}/src/tensoracle/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.3.0'
-__version_tuple__ = version_tuple = (1, 3, 0)
+__version__ = version = '1.4.0'
+__version_tuple__ = version_tuple = (1, 4, 0)
 
 __commit_id__ = commit_id = None

tensoracle-1.4.0/tests/test_cmake_cuda.py

@@ -0,0 +1,199 @@
+"""Consumers can inspect and link the same CUDA inputs as the cubin plugin helper."""
+
+import os
+import re
+import subprocess
+from pathlib import Path
+
+import pytest
+
+PROJECT = Path(__file__).resolve().parents[1]
+ROOT = PROJECT.parent if PROJECT.name == "python" else PROJECT
+HELPER = ROOT / "cpp/cmake/TensoracleCubinPlugin.cmake"
+FIND_CUDA = "tensoracle_find_cuda(OUT_INCLUDE_DIR cuda_include OUT_DRIVER_LIBRARY cuda_driver)\n"
+ADD_PLUGIN = (
+    "tensoracle_add_cubin_plugin(TARGET plugin\n"
+    '  TENSORRT_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/sdk"\n'
+    '  BUNDLE_ROOT "${CMAKE_CURRENT_SOURCE_DIR}"\n'
+    '  SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/plugin.cpp")\n'
+)
+
+
+def configure(source, build_name, *, cuda, root_input="cmake-root"):
+    environment = dict(os.environ)
+    environment.pop("CUDAToolkit_ROOT", None)
+    arguments = []
+    if root_input == "env-root":
+        environment["CUDAToolkit_ROOT"] = str(cuda)
+    elif root_input == "default-root":
+        arguments.append(f"-DCMAKE_CUDA_COMPILER_TOOLKIT_ROOT={cuda.as_posix()}")
+    else:
+        # The CMake variable takes precedence over an environment root.
+        environment["CUDAToolkit_ROOT"] = str(source / "unused-cuda")
+        arguments.append(f"-DCUDAToolkit_ROOT={cuda.as_posix()}")
+    return subprocess.run(
+        ["cmake", "-S", str(source), "-B", str(source / build_name), *arguments],
+        env=environment,
+        capture_output=True,
+        text=True,
+        check=False,
+        timeout=45,
+    )
+
+
+def platform_settings(windows):
+    if windows:
+        return (
+            "set(WIN32 TRUE)\n"
+            'set(CMAKE_FIND_LIBRARY_PREFIXES "")\n'
+            'set(CMAKE_FIND_LIBRARY_SUFFIXES ".lib")\n'
+        )
+    return (
+        "set(WIN32 FALSE)\n"
+        'set(CMAKE_FIND_LIBRARY_PREFIXES "lib")\n'
+        'set(CMAKE_FIND_LIBRARY_SUFFIXES ".so")\n'
+    )
+
+
+@pytest.mark.req("SP-TENSORACLE-040")
+@pytest.mark.parametrize("windows", [False, True], ids=["linux", "windows"])
+@pytest.mark.parametrize("root_input", ["cmake-root", "env-root", "default-root"])
+@pytest.mark.parametrize("plugin_first", [False, True], ids=["paths-first", "plugin-first"])
+def test_public_cuda_paths_match_plugin_and_linked_consumer(
+    tmp_path, windows, root_input, plugin_first
+):
+    """CUDA paths match the plugin and linked consumers, including repeated discovery."""
+    cuda = tmp_path / "wheel site-packages/nvidia/cu13"
+    headers = cuda / "include"
+    headers.mkdir(parents=True)
+    (headers / "cuda.h").touch()
+    driver = cuda / ("lib/x64/cuda.lib" if windows else "lib/libcuda.so")
+    driver.parent.mkdir(parents=True)
+    driver.touch()
+    (tmp_path / "sdk/include").mkdir(parents=True)
+    (tmp_path / "sdk/include/NvInfer.h").touch()
+    (tmp_path / "sdk/lib").mkdir()
+    (tmp_path / "sdk/lib" / ("nvinfer_11.lib" if windows else "libnvinfer.so")).touch()
+    (tmp_path / "plugin.cpp").touch()
+    (tmp_path / "bundle.cpp").touch()
+    calls = ADD_PLUGIN + FIND_CUDA if plugin_first else FIND_CUDA + ADD_PLUGIN
+    (tmp_path / "CMakeLists.txt").write_text(
+        "cmake_minimum_required(VERSION 3.20)\n"
+        "project(check_cuda_paths LANGUAGES CXX)\n"
+        + platform_settings(windows)
+        + f'include("{HELPER.as_posix()}")\n'
+        + calls
+        + "tensoracle_find_cuda(OUT_DRIVER_LIBRARY repeated_driver\n"
+        "  OUT_INCLUDE_DIR repeated_include)\n"
+        'if(NOT "${cuda_include}" STREQUAL "${repeated_include}" OR\n'
+        '   NOT "${cuda_driver}" STREQUAL "${repeated_driver}")\n'
+        '  message(FATAL_ERROR "Repeated CUDA discovery changed the paths")\n'
+        "endif()\n"
+        "get_target_property(headers tensoracle_cuda_driver INTERFACE_INCLUDE_DIRECTORIES)\n"
+        "get_target_property(driver tensoracle_cuda_driver IMPORTED_LOCATION)\n"
+        "get_target_property(imported tensoracle_cuda_driver IMPORTED)\n"
+        'file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/public.txt"\n'
+        '  "${cuda_include}\\n${cuda_driver}\\n${headers}\\n${driver}\\n${imported}")\n'
+        "get_target_property(dependencies plugin LINK_LIBRARIES)\n"
+        "foreach(dependency IN LISTS dependencies)\n"
+        '  if(TARGET "${dependency}")\n'
+        '    get_target_property(location "${dependency}" IMPORTED_LOCATION)\n'
+        '    get_target_property(headers "${dependency}" INTERFACE_INCLUDE_DIRECTORIES)\n'
+        "    if(location)\n"
+        '      file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/plugin.txt" "${headers}\\n${location}")\n'
+        "    endif()\n"
+        "  endif()\n"
+        "endforeach()\n"
+        "add_library(consumer SHARED plugin.cpp)\n"
+        "target_link_libraries(consumer PRIVATE tensoracle_cuda_driver)\n"
+        "get_target_property(consumer_driver consumer LINK_LIBRARIES)\n"
+        'file(GENERATE OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/consumer-$<CONFIG>.txt"\n'
+        '  CONTENT "$<TARGET_PROPERTY:consumer,INCLUDE_DIRECTORIES>\\n'
+        '$<TARGET_FILE:${consumer_driver}>")\n',
+        encoding="utf-8",
+    )
+    result = configure(tmp_path, "build with spaces", cuda=cuda, root_input=root_input)
+    assert result.returncode == 0, result.stdout + result.stderr
+    build = tmp_path / "build with spaces"
+    include, library, target_include, target_library, imported = (
+        (build / "public.txt").read_text(encoding="utf-8").splitlines()
+    )
+    assert Path(include) == headers
+    # Linux may prefer the installed driver's library over the wheel root.
+    assert Path(library) == driver if windows else Path(library).name == "libcuda.so"
+    assert [target_include, target_library, imported] == [include, library, "TRUE"]
+    assert (build / "plugin.txt").read_text(encoding="utf-8").splitlines() == [include, library]
+    for consumer in build.glob("consumer-*.txt"):
+        assert consumer.read_text(encoding="utf-8").splitlines() == [include, library]
+    assert list(build.glob("consumer-*.txt"))
+
+
+@pytest.mark.req("SP-TENSORACLE-040")
+@pytest.mark.parametrize("windows", [False, True], ids=["linux", "windows"])
+@pytest.mark.parametrize("missing", ["headers", "driver"])
+def test_public_cuda_discovery_reports_the_same_missing_input_as_plugin(tmp_path, windows, missing):
+    """Missing CUDA headers and driver libraries report the plugin's discovery error."""
+    cuda = tmp_path / "missing cuda"
+    if missing == "driver":
+        (cuda / "include").mkdir(parents=True)
+        (cuda / "include/cuda.h").touch()
+    errors = []
+    for name, call in [("plugin", ADD_PLUGIN), ("public", FIND_CUDA)]:
+        (tmp_path / "CMakeLists.txt").write_text(
+            "cmake_minimum_required(VERSION 3.20)\n"
+            "project(missing_cuda LANGUAGES NONE)\n"
+            + platform_settings(windows)
+            # Isolate library lookup from any driver installed on the test host.
+            + "set(CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH FALSE)\n"
+            "set(CMAKE_FIND_USE_CMAKE_SYSTEM_PATH FALSE)\n"
+            "set(CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH FALSE)\n"
+            "set(CMAKE_FIND_USE_CMAKE_PATH FALSE)\n"
+            'set(CMAKE_IGNORE_PATH "/usr/lib/wsl/lib")\n'
+            + f'include("{HELPER.as_posix()}")\n'
+            + call,
+            encoding="utf-8",
+        )
+        result = configure(tmp_path, f"build-{name}", cuda=cuda)
+        assert result.returncode != 0
+        message = result.stdout + result.stderr
+        match = re.search(
+            r"CMake Error at [^\n]*TensoracleCuda.cmake:\d+ \(message\):\n(.*?)\nCall Stack",
+            message,
+            re.DOTALL,
+        )
+        assert match, message
+        error = " ".join(match.group(1).split())
+        assert ("cuda.h" if missing == "headers" else "driver link library") in error
+        assert cuda.as_posix() in error
+        errors.append(error)
+    assert errors[0] == errors[1]
+
+
+@pytest.mark.req("SP-TENSORACLE-040")
+@pytest.mark.parametrize(
+    ("arguments", "expected"),
+    [
+        ("", "OUT_INCLUDE_DIR"),
+        ("OUT_INCLUDE_DIR headers", "OUT_DRIVER_LIBRARY"),
+        ("OUT_DRIVER_LIBRARY driver", "OUT_INCLUDE_DIR"),
+        ("OUT_INCLUDE_DIR OUT_DRIVER_LIBRARY driver", "OUT_INCLUDE_DIR"),
+        ("OUT_INCLUDE_DIR headers OUT_DRIVER_LIBRARY", "OUT_DRIVER_LIBRARY"),
+        ("OUT_INCLUDE_DIR inc OUT_DRIVER_LIBRARY lib OUT_INCLUDE_DIR", "OUT_INCLUDE_DIR"),
+        ("OUT_INCLUDE_DIR inc OUT_DRIVER_LIBRARY lib OUT_DRIVER_LIBRARY", "OUT_DRIVER_LIBRARY"),
+        ("OUT_INCLUDE_DIR headers OUT_DRIVER_LIBRARY driver UNKNOWN value", "UNKNOWN"),
+    ],
+)
+def test_public_cuda_discovery_rejects_invalid_output_arguments(tmp_path, arguments, expected):
+    """CUDA discovery rejects missing output variable names and unknown arguments."""
+    (tmp_path / "CMakeLists.txt").write_text(
+        "cmake_minimum_required(VERSION 3.20)\n"
+        "project(invalid_cuda_arguments LANGUAGES NONE)\n"
+        f'include("{HELPER.as_posix()}")\n'
+        f"tensoracle_find_cuda({arguments})\n",
+        encoding="utf-8",
+    )
+    result = configure(tmp_path, "build", cuda=tmp_path / "unused-cuda")
+    assert result.returncode != 0
+    message = result.stdout + result.stderr
+    assert "tensoracle_find_cuda" in message
+    assert expected in message

{tensoracle-1.3.0 → tensoracle-1.4.0}/tests/test_cmake_plugin.py

@@ -7,6 +7,77 @@ from pathlib import Path
 import pytest
 
 
+@pytest.mark.req("SP-TENSORACLE-004")
+@pytest.mark.req("SP-TENSORACLE-015")
+@pytest.mark.skipif(os.name == "nt", reason="The pthread link check uses a Unix C++ toolchain")
+@pytest.mark.parametrize("windows", [False, True], ids=["linux", "windows"])
+@pytest.mark.parametrize("target_kind", ["plugin", "static-library"])
+def test_cubin_targets_link_platform_threads(tmp_path, windows, target_kind):
+    """Linux plugins and static library consumers link threads; Windows needs no package."""
+    project = Path(__file__).resolve().parents[1]
+    root = project.parent if project.name == "python" else project
+    sdk = tmp_path / "sdk"
+    (sdk / "include").mkdir(parents=True)
+    (sdk / "include/NvInfer.h").touch()
+    (sdk / "lib").mkdir()
+    (sdk / "lib" / ("nvinfer_11.lib" if windows else "libnvinfer.so")).touch()
+    cuda = tmp_path / "cuda"
+    (cuda / "include").mkdir(parents=True)
+    (cuda / "include/cuda.h").touch()
+    driver = cuda / ("lib/x64/cuda.lib" if windows else "lib/libcuda.so")
+    driver.parent.mkdir(parents=True)
+    driver.touch()
+    (tmp_path / "plugin.cpp").touch()
+    (tmp_path / "bundle.cpp").touch()
+    platform = (
+        'set(WIN32 TRUE)\nset(CMAKE_FIND_LIBRARY_PREFIXES "")\n'
+        'set(CMAKE_FIND_LIBRARY_SUFFIXES ".lib")\n'
+        "set(CMAKE_DISABLE_FIND_PACKAGE_Threads TRUE)\n"
+        if windows
+        else "set(WIN32 FALSE)\n"
+        # Model a libc that requires explicit thread linkage, even on glibc >= 2.34.
+        'set(CMAKE_HAVE_LIBC_PTHREAD FALSE CACHE BOOL "" FORCE)\n'
+        "set(THREADS_PREFER_PTHREAD_FLAG TRUE)\n"
+    )
+    target = (
+        f'include("{root.as_posix()}/cpp/cmake/TensoracleCubinPlugin.cmake")\n'
+        "tensoracle_add_cubin_plugin(TARGET check_threads\n"
+        '  TENSORRT_ROOT "${TENSORRT_ROOT}" BUNDLE_ROOT "${CMAKE_CURRENT_SOURCE_DIR}"\n'
+        '  SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/plugin.cpp")\n'
+        if target_kind == "plugin"
+        else 'set(BUILD_TESTING OFF CACHE BOOL "" FORCE)\n'
+        f'add_subdirectory("{root.as_posix()}/cpp" cpp)\n'
+        "add_executable(check_threads plugin.cpp)\n"
+        "target_link_libraries(check_threads PRIVATE tensoracle_cubin)\n"
+    )
+    (tmp_path / "CMakeLists.txt").write_text(
+        "cmake_minimum_required(VERSION 3.20)\n"
+        "project(check_threads LANGUAGES CXX)\n" + platform + target,
+        encoding="utf-8",
+    )
+    build = tmp_path / "build"
+    result = subprocess.run(
+        [
+            "cmake",
+            "-S",
+            str(tmp_path),
+            "-B",
+            str(build),
+            "-G",
+            "Unix Makefiles",
+            f"-DTENSORRT_ROOT={sdk}",
+            f"-DCUDAToolkit_ROOT={cuda}",
+        ],
+        capture_output=True,
+        text=True,
+        check=False,
+        timeout=45,
+    )
+    assert result.returncode == 0, result.stdout + result.stderr
+    link = (build / "CMakeFiles/check_threads.dir/link.txt").read_text(encoding="utf-8")
+    assert ("-pthread" in link.split()) is not windows, link
+
+
 @pytest.mark.req("SP-TENSORACLE-004")
 @pytest.mark.req("SP-TENSORACLE-015")
 @pytest.mark.req("SP-TENSORACLE-038")