tensoracle 1.2.0__tar.gz → 1.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tensoracle
-Version: 1.2.0
+Version: 1.3.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
@@ -24,6 +24,10 @@ Requires-Dist: tensorrt-cu13<12,>=11.0
 Provides-Extra: convert
 Requires-Dist: torch>=2.6; extra == 'convert'
 Provides-Extra: producer
+Requires-Dist: nvidia-cuda-crt==13.2.*; extra == 'producer'
+Requires-Dist: nvidia-cuda-cuobjdump==13.2.*; extra == 'producer'
+Requires-Dist: nvidia-cuda-nvcc==13.2.*; extra == 'producer'
+Requires-Dist: nvidia-nvvm==13.2.*; extra == 'producer'
 Requires-Dist: triton==3.8.0; extra == 'producer'
 Description-Content-Type: text/markdown
 
@@ -43,7 +47,7 @@ Choose the path that matches your work:
 | --- | --- | --- |
 | Inference application | [Reopen a saved engine](#use-a-saved-engine-for-inference) and enqueue it with `handle.create_execution()`. | The application supplies device buffers and CUDA streams, for example through CuPy or `cuda-python`. |
 | Standard graph developer | [Define and build a graph](#define-and-build-a-standard-graph), [save and reopen](#save-and-reopen-an-engine), and [compare outputs](#compare-output-arrays). | None for standard TensorRT layers. |
-| Cubin plugin developer | [Build a cubin plugin](#build-a-cubin-plugin) and package it with the model. | `tensoracle[producer]`, CUDA toolkit, TensorRT SDK, CMake 3.20 or later, and a C++17 compiler. |
+| Cubin plugin developer | [Build a cubin plugin](#build-a-cubin-plugin) and package it with the model. | `tensoracle[producer]`, PyPI CUDA headers, TensorRT SDK, CMake 3.20 or later, and a C++17 compiler. |
 
 | Requirement | Inference application | Standard graph developer | Cubin plugin developer |
 | --- | --- | --- | --- |
@@ -52,7 +56,7 @@ Choose the path that matches your work:
 | NVIDIA GPU and driver | Open and run engines | Build and run engines | Run and test engines; cubin production itself can run without a GPU |
 | CuPy or `cuda-python` | The application chooses its buffer and stream library | The application chooses its buffer and stream library | `cuda-python` is used by the example runtime and tests, not by `tensoracle` |
 | Triton 3.8.0 | Not needed | Not needed | Installed with `tensoracle[producer]` for cubin production |
-| CUDA toolkit | Not needed | Not needed | Cubin production (`ptxas >=13.2,<14` and `cuobjdump`) and native plugin build |
+| PyPI CUDA tools and headers | Not needed | Not needed | `tensoracle[producer]` supplies cubin tools; `nvidia-cuda-nvcc` and `nvidia-cuda-runtime` 13.2 supply the native build inputs |
 | TensorRT 11 SDK | Not needed | Not needed | Native plugin build |
 | CMake 3.20 or later and C++17 compiler | Not needed | Not needed | Native plugin build |
 
@@ -344,7 +348,9 @@ python/
 
 Keep C++ sources in `cpp/`, with a CMake project that builds and runs its tests through CTest without Python. Keep the Python project, its src-layout package, and its uv environment in `python/`; run the project's uv commands from that directory. Tensoracle itself follows this layout, and the installed C++ helper paths described below remain inside its Python package.
 
-`tensoracle.producer.compile_bundle` uses the extra's **Triton 3.8.0** with **ptxas >=13.2,<14** and **cuobjdump** from the host CUDA toolkit. It uses the toolkit directory named by `CUDA_HOME`, or `/usr/local/cuda` when `CUDA_HOME` is unset; explicit `ptxas` and `cuobjdump` paths override these defaults independently. The normal import, engine build, and engine reuse paths do not import the producer or Triton. Cubin production does not need a GPU or import torch; run it without importing torch first. The caller supplies Triton functions and `KernelSpec` records with their public argument types, compile time constants, and any divisibility assumptions. The producer writes sm86, sm89, and sm120 cubins, `bundle.json`, and a C++ translation unit that embeds exactly those cubins. The generated C++ entry records carry each public argument's order, type, count, and divisibility rule into the common launcher. It rejects an unexpected parameter ABI or nonzero scratch requirement. The included [example](https://github.com/sync-dev-org/tensoracle/blob/main/examples/cubin_plugin/README.md#rebuild-the-cubins) has the command to rebuild its cubins from a repository clone.
+`tensoracle.producer.compile_bundle` uses the extra's **Triton 3.8.0** with **ptxas >=13.2,<14** and **cuobjdump** from the PyPI `nvidia-cuda-nvcc` and `nvidia-cuda-cuobjdump` wheels. The extra pins those tools, `nvidia-cuda-crt`, and `nvidia-nvvm` to the 13.2 series. It does not read `CUDA_HOME`; explicit `ptxas` and `cuobjdump` paths override the wheel defaults independently. A missing tool identifies its package and searched path and explains how to install the extra or pass a path. The normal import, engine build, and engine reuse paths do not import the producer or Triton. Cubin production does not need a GPU or import torch; run it without importing torch first. The caller supplies Triton functions and `KernelSpec` records with their public argument types, compile time constants, and any divisibility assumptions. The producer writes sm86, sm89, and sm120 cubins, `bundle.json`, and a C++ translation unit that embeds exactly those cubins. The generated C++ entry records carry each public argument's order, type, count, and divisibility rule into the common launcher. It rejects an unexpected parameter ABI or nonzero scratch requirement. The included [example](https://github.com/sync-dev-org/tensoracle/blob/main/examples/cubin_plugin/README.md#rebuild-the-cubins) has the command to rebuild its cubins from a repository clone.
+
+Neither cubin production nor native plugin building requires an OS-installed CUDA Toolkit. For the native build, install PyPI `nvidia-cuda-nvcc==13.2.*` and `nvidia-cuda-runtime==13.2.*`, then pass their `site-packages/nvidia/cu13` directory as `CUDAToolkit_ROOT` (a CMake variable or environment variable). The helper uses its `cuda.h` and links the NVIDIA driver's `libcuda.so` on Linux, including `/usr/lib/wsl/lib/libcuda.so` on WSL, or the wheel's `lib/x64/cuda.lib` on Windows. TensorRT headers still come from the separately prepared SDK. The [SDK guide](https://github.com/sync-dev-org/tensoracle/blob/main/docs/tensorrt-sdk.md#5-pass-the-verified-root-to-the-build-and-tests) gives the setup commands. An explicit OS Toolkit root and the existing default locations remain supported for native builds.
 
 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.
 

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

@@ -14,7 +14,7 @@ Choose the path that matches your work:
 | --- | --- | --- |
 | Inference application | [Reopen a saved engine](#use-a-saved-engine-for-inference) and enqueue it with `handle.create_execution()`. | The application supplies device buffers and CUDA streams, for example through CuPy or `cuda-python`. |
 | Standard graph developer | [Define and build a graph](#define-and-build-a-standard-graph), [save and reopen](#save-and-reopen-an-engine), and [compare outputs](#compare-output-arrays). | None for standard TensorRT layers. |
-| Cubin plugin developer | [Build a cubin plugin](#build-a-cubin-plugin) and package it with the model. | `tensoracle[producer]`, CUDA toolkit, TensorRT SDK, CMake 3.20 or later, and a C++17 compiler. |
+| Cubin plugin developer | [Build a cubin plugin](#build-a-cubin-plugin) and package it with the model. | `tensoracle[producer]`, PyPI CUDA headers, TensorRT SDK, CMake 3.20 or later, and a C++17 compiler. |
 
 | Requirement | Inference application | Standard graph developer | Cubin plugin developer |
 | --- | --- | --- | --- |
@@ -23,7 +23,7 @@ Choose the path that matches your work:
 | NVIDIA GPU and driver | Open and run engines | Build and run engines | Run and test engines; cubin production itself can run without a GPU |
 | CuPy or `cuda-python` | The application chooses its buffer and stream library | The application chooses its buffer and stream library | `cuda-python` is used by the example runtime and tests, not by `tensoracle` |
 | Triton 3.8.0 | Not needed | Not needed | Installed with `tensoracle[producer]` for cubin production |
-| CUDA toolkit | Not needed | Not needed | Cubin production (`ptxas >=13.2,<14` and `cuobjdump`) and native plugin build |
+| PyPI CUDA tools and headers | Not needed | Not needed | `tensoracle[producer]` supplies cubin tools; `nvidia-cuda-nvcc` and `nvidia-cuda-runtime` 13.2 supply the native build inputs |
 | TensorRT 11 SDK | Not needed | Not needed | Native plugin build |
 | CMake 3.20 or later and C++17 compiler | Not needed | Not needed | Native plugin build |
 
@@ -315,7 +315,9 @@ python/
 
 Keep C++ sources in `cpp/`, with a CMake project that builds and runs its tests through CTest without Python. Keep the Python project, its src-layout package, and its uv environment in `python/`; run the project's uv commands from that directory. Tensoracle itself follows this layout, and the installed C++ helper paths described below remain inside its Python package.
 
-`tensoracle.producer.compile_bundle` uses the extra's **Triton 3.8.0** with **ptxas >=13.2,<14** and **cuobjdump** from the host CUDA toolkit. It uses the toolkit directory named by `CUDA_HOME`, or `/usr/local/cuda` when `CUDA_HOME` is unset; explicit `ptxas` and `cuobjdump` paths override these defaults independently. The normal import, engine build, and engine reuse paths do not import the producer or Triton. Cubin production does not need a GPU or import torch; run it without importing torch first. The caller supplies Triton functions and `KernelSpec` records with their public argument types, compile time constants, and any divisibility assumptions. The producer writes sm86, sm89, and sm120 cubins, `bundle.json`, and a C++ translation unit that embeds exactly those cubins. The generated C++ entry records carry each public argument's order, type, count, and divisibility rule into the common launcher. It rejects an unexpected parameter ABI or nonzero scratch requirement. The included [example](https://github.com/sync-dev-org/tensoracle/blob/main/examples/cubin_plugin/README.md#rebuild-the-cubins) has the command to rebuild its cubins from a repository clone.
+`tensoracle.producer.compile_bundle` uses the extra's **Triton 3.8.0** with **ptxas >=13.2,<14** and **cuobjdump** from the PyPI `nvidia-cuda-nvcc` and `nvidia-cuda-cuobjdump` wheels. The extra pins those tools, `nvidia-cuda-crt`, and `nvidia-nvvm` to the 13.2 series. It does not read `CUDA_HOME`; explicit `ptxas` and `cuobjdump` paths override the wheel defaults independently. A missing tool identifies its package and searched path and explains how to install the extra or pass a path. The normal import, engine build, and engine reuse paths do not import the producer or Triton. Cubin production does not need a GPU or import torch; run it without importing torch first. The caller supplies Triton functions and `KernelSpec` records with their public argument types, compile time constants, and any divisibility assumptions. The producer writes sm86, sm89, and sm120 cubins, `bundle.json`, and a C++ translation unit that embeds exactly those cubins. The generated C++ entry records carry each public argument's order, type, count, and divisibility rule into the common launcher. It rejects an unexpected parameter ABI or nonzero scratch requirement. The included [example](https://github.com/sync-dev-org/tensoracle/blob/main/examples/cubin_plugin/README.md#rebuild-the-cubins) has the command to rebuild its cubins from a repository clone.
+
+Neither cubin production nor native plugin building requires an OS-installed CUDA Toolkit. For the native build, install PyPI `nvidia-cuda-nvcc==13.2.*` and `nvidia-cuda-runtime==13.2.*`, then pass their `site-packages/nvidia/cu13` directory as `CUDAToolkit_ROOT` (a CMake variable or environment variable). The helper uses its `cuda.h` and links the NVIDIA driver's `libcuda.so` on Linux, including `/usr/lib/wsl/lib/libcuda.so` on WSL, or the wheel's `lib/x64/cuda.lib` on Windows. TensorRT headers still come from the separately prepared SDK. The [SDK guide](https://github.com/sync-dev-org/tensoracle/blob/main/docs/tensorrt-sdk.md#5-pass-the-verified-root-to-the-build-and-tests) gives the setup commands. An explicit OS Toolkit root and the existing default locations remain supported for native builds.
 
 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.
 

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

@@ -5,13 +5,14 @@ set(TENSORRT_ROOT "" CACHE PATH "TensorRT 11 SDK root containing include/NvInfer
 if(NOT EXISTS "${TENSORRT_ROOT}/include/NvInfer.h")
     message(FATAL_ERROR "TensorRT SDK headers are missing; set TENSORRT_ROOT to the TensorRT 11 SDK")
 endif()
-find_package(CUDAToolkit REQUIRED)
+include(cmake/TensoracleCuda.cmake)
+_tensoracle_find_cuda()
 
 add_library(tensoracle_cubin STATIC src/cubin_plugin.cpp)
 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 CUDA::cuda_driver)
+target_link_libraries(tensoracle_cubin PUBLIC tensoracle_internal_cuda_driver)
 target_compile_options(tensoracle_cubin PRIVATE
     $<$<CXX_COMPILER_ID:GNU,Clang>:-Wno-deprecated-declarations>)
 

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

@@ -1,4 +1,5 @@
 include_guard(GLOBAL)
+include("${CMAKE_CURRENT_LIST_DIR}/TensoracleCuda.cmake")
 
 function(tensoracle_add_cubin_plugin)
     cmake_parse_arguments(ARG "" "TARGET;TENSORRT_ROOT;BUNDLE_ROOT" "SOURCES" ${ARGN})
@@ -7,7 +8,7 @@ function(tensoracle_add_cubin_plugin)
     endif()
 
     get_filename_component(_tensoracle_cpp "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/.." ABSOLUTE)
-    find_package(CUDAToolkit REQUIRED)
+    _tensoracle_find_cuda()
     find_path(TENSORACLE_NVINFER_INCLUDE NvInfer.h
         PATHS "${ARG_TENSORRT_ROOT}/include" NO_DEFAULT_PATH REQUIRED)
     set(_tensoracle_nvinfer_names nvinfer)
@@ -26,8 +27,9 @@ function(tensoracle_add_cubin_plugin)
     target_compile_options(${ARG_TARGET} PRIVATE
         $<$<CXX_COMPILER_ID:GNU,Clang>:-Wno-deprecated-declarations>)
     target_include_directories(${ARG_TARGET} PRIVATE
-        "${_tensoracle_cpp}/include" "${TENSORACLE_NVINFER_INCLUDE}" ${CUDAToolkit_INCLUDE_DIRS})
-    target_link_libraries(${ARG_TARGET} PRIVATE "${TENSORACLE_NVINFER_LIBRARY}" CUDA::cuda_driver)
+        "${_tensoracle_cpp}/include" "${TENSORACLE_NVINFER_INCLUDE}")
+    target_link_libraries(${ARG_TARGET} PRIVATE
+        "${TENSORACLE_NVINFER_LIBRARY}" tensoracle_internal_cuda_driver)
     set_target_properties(${ARG_TARGET} PROPERTIES
         CXX_VISIBILITY_PRESET hidden VISIBILITY_INLINES_HIDDEN YES)
 endfunction()

tensoracle-1.3.0/cpp/cmake/TensoracleCuda.cmake

@@ -0,0 +1,95 @@
+include_guard(GLOBAL)
+
+# Only the Driver API is needed by the C++ helpers. A PyPI CUDA root has neither
+# the unversioned cudart linker name nor all the headers of a complete toolkit.
+function(_tensoracle_find_cuda)
+    if(CUDAToolkit_ROOT)
+        set(_roots "${CUDAToolkit_ROOT}")
+    elseif(DEFINED ENV{CUDAToolkit_ROOT} AND NOT "$ENV{CUDAToolkit_ROOT}" STREQUAL "")
+        set(_roots "$ENV{CUDAToolkit_ROOT}")
+    else()
+        set(_roots "${CMAKE_CUDA_COMPILER_TOOLKIT_ROOT}")
+        foreach(_compiler IN ITEMS "${CMAKE_CUDA_COMPILER}" "$ENV{CUDACXX}")
+            if(EXISTS "${_compiler}")
+                get_filename_component(_bin "${_compiler}" DIRECTORY)
+                get_filename_component(_root "${_bin}/.." ABSOLUTE)
+                list(APPEND _roots "${_root}")
+            endif()
+        endforeach()
+        find_program(_tensoracle_cuda_nvcc NAMES nvcc nvcc.exe)
+        if(_tensoracle_cuda_nvcc)
+            get_filename_component(_nvcc "${_tensoracle_cuda_nvcc}" REALPATH)
+            get_filename_component(_bin "${_nvcc}" DIRECTORY)
+            get_filename_component(_root "${_bin}/.." ABSOLUTE)
+            list(APPEND _roots "${_root}")
+        endif()
+        # Remove private find results before CMake writes its cache (CMake 3.20
+        # predates find_program/find_library's NO_CACHE option).
+        unset(_tensoracle_cuda_nvcc CACHE)
+        if(DEFINED ENV{CUDA_PATH})
+            list(APPEND _roots "$ENV{CUDA_PATH}")
+        endif()
+        if(WIN32)
+            file(GLOB _defaults "C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v*")
+        else()
+            file(GLOB _defaults "/usr/local/cuda-*")
+            list(APPEND _roots "/usr/local/cuda")
+        endif()
+        list(SORT _defaults COMPARE NATURAL ORDER DESCENDING)
+        list(APPEND _roots ${_defaults})
+    endif()
+
+    set(_searched_includes)
+    set(_include)
+    foreach(_root IN LISTS _roots)
+        foreach(_candidate IN ITEMS "${_root}/include" "${_root}/targets/x86_64-linux/include")
+            list(APPEND _searched_includes "${_candidate}")
+            if(EXISTS "${_candidate}/cuda.h")
+                set(_include "${_candidate}")
+                set(_selected_root "${_root}")
+                break()
+            endif()
+        endforeach()
+        if(_include)
+            break()
+        endif()
+    endforeach()
+    set(_root "${_selected_root}")
+    if(NOT _include)
+        message(FATAL_ERROR "CUDA header cuda.h was not found. Searched: ${_searched_includes}. "
+            "Install PyPI nvidia-cuda-nvcc and nvidia-cuda-runtime 13.2 and set "
+            "CUDAToolkit_ROOT to their site-packages/nvidia/cu13 directory.")
+    endif()
+
+    if(WIN32)
+        set(_driver_paths "${_root}/lib/x64")
+        find_library(_tensoracle_cuda_driver_library NAMES cuda
+            PATHS ${_driver_paths} NO_DEFAULT_PATH)
+    else()
+        set(_driver_paths "/usr/lib/wsl/lib" "${_root}/lib64" "${_root}/lib"
+            "${_root}/targets/x86_64-linux/lib")
+        find_library(_tensoracle_cuda_driver_library NAMES cuda HINTS ${_driver_paths})
+        if(NOT _tensoracle_cuda_driver_library)
+            list(APPEND _driver_paths "${_root}/lib64/stubs" "${_root}/lib/stubs"
+                "${_root}/targets/x86_64-linux/lib/stubs")
+            find_library(_tensoracle_cuda_driver_library NAMES cuda
+                PATHS ${_driver_paths} NO_DEFAULT_PATH)
+        endif()
+    endif()
+    set(_driver "${_tensoracle_cuda_driver_library}")
+    unset(_tensoracle_cuda_driver_library CACHE)
+    if(NOT _driver)
+        message(FATAL_ERROR "CUDA driver link library was not found. Searched: ${_driver_paths} "
+            "and system library directories. Install the NVIDIA driver on Linux; on Windows "
+            "install PyPI nvidia-cuda-runtime 13.2 and set CUDAToolkit_ROOT to its "
+            "site-packages/nvidia/cu13 directory (lib/x64/cuda.lib).")
+    endif()
+    message(STATUS "tensoracle CUDA headers: ${_include}")
+    message(STATUS "tensoracle CUDA driver: ${_driver}")
+    if(NOT TARGET tensoracle_internal_cuda_driver)
+        add_library(tensoracle_internal_cuda_driver UNKNOWN IMPORTED GLOBAL)
+        set_target_properties(tensoracle_internal_cuda_driver PROPERTIES
+            IMPORTED_LOCATION "${_driver}" INTERFACE_INCLUDE_DIRECTORIES "${_include}")
+    endif()
+    set(_tensoracle_cuda_root "${_root}" PARENT_SCOPE)
+endfunction()

tensoracle-1.3.0/docs/api/producer.md

@@ -0,0 +1,11 @@
+# Cubin producer API
+
+The following names are available from `tensoracle.producer`. Install `tensoracle[producer]` for Triton 3.8.0 and the PyPI CUDA tools; no OS-installed CUDA Toolkit is required. The extra declares `nvidia-cuda-nvcc`, `nvidia-cuda-cuobjdump`, `nvidia-cuda-crt`, and `nvidia-nvvm` in the 13.2 series.
+
+`compile_bundle` obtains `ptxas` from `nvidia-cuda-nvcc` at `nvidia/cu13/bin/ptxas` and `cuobjdump` from `nvidia-cuda-cuobjdump` at `nvidia/cu13/bin/cuobjdump` (with `.exe` on Windows). It ignores `CUDA_HOME`. Explicit `ptxas` and `cuobjdump` paths override the defaults independently. A missing wheel or executable reports the package and searched path and explains how to install `tensoracle[producer]` or pass an explicit path. The producer rejects ptxas versions outside `>=13.2,<14` before writing cubins or a manifest.
+
+Cubin production does not need a GPU. Triton production runs on Linux; the resulting cubins can also be embedded in a Windows plugin DLL. Normal imports, engine building, and engine reuse do not import the producer or Triton.
+
+::: tensoracle.producer.KernelSpec
+
+::: tensoracle.producer.compile_bundle

{tensoracle-1.2.0 → tensoracle-1.3.0}/docs/index.md

@@ -18,7 +18,7 @@ Follow [Build a C++ and Python repository](cpp-python-repositories.md) for sourc
 | --- | --- | --- |
 | Inference application | Use `open_engine` to reopen a matching saved engine, then enqueue it with `handle.create_execution()`. | The application supplies buffers and streams, for example through CuPy or `cuda-python`. |
 | Standard graph developer | Define a TensorRT graph, build it with `build_serialized_engine` or `open_engine`, and measure outputs with `compare_outputs`. | None for standard TensorRT layers. |
-| Cubin plugin developer | Produce cubins, build a native TensorRT plugin, and package it with the model. | `tensoracle[producer]`, CUDA toolkit, TensorRT SDK, CMake 3.20 or later, and a C++17 compiler. |
+| Cubin plugin developer | Produce cubins, build a native TensorRT plugin, and package it with the model. | `tensoracle[producer]`, PyPI CUDA headers, TensorRT SDK, CMake 3.20 or later, and a C++17 compiler. |
 
 | Requirement | Inference application | Standard graph developer | Cubin plugin developer |
 | --- | --- | --- | --- |
@@ -27,7 +27,7 @@ Follow [Build a C++ and Python repository](cpp-python-repositories.md) for sourc
 | NVIDIA GPU and driver | Open and run engines | Build and run engines | Run and test engines; cubin production itself can run without a GPU |
 | CuPy or `cuda-python` | The application chooses its buffer and stream library | The application chooses its buffer and stream library | `cuda-python` is used by the example runtime and tests, not by `tensoracle` |
 | Triton 3.8.0 | Not needed | Not needed | Installed with `tensoracle[producer]` for cubin production |
-| CUDA toolkit | Not needed | Not needed | Cubin production (`ptxas >=13.2,<14` and `cuobjdump`) and native plugin build |
+| PyPI CUDA tools and headers | Not needed | Not needed | `tensoracle[producer]` supplies cubin tools; `nvidia-cuda-nvcc` and `nvidia-cuda-runtime` 13.2 supply the native build inputs |
 | TensorRT 11 SDK | Not needed | Not needed | Native plugin build |
 | CMake 3.20 or later and C++17 compiler | Not needed | Not needed | Native plugin build |
 
@@ -242,7 +242,9 @@ Install `tensoracle[producer]` when you need to compile cubins from your own ker
 pip install 'tensoracle[producer]'
 ```
 
-`tensoracle.producer.compile_bundle` uses the extra's Triton 3.8.0 with `ptxas >=13.2,<14` and `cuobjdump` from the host CUDA toolkit to produce cubins for sm86, sm89, and sm120. It uses the toolkit directory named by `CUDA_HOME`, or `/usr/local/cuda` when `CUDA_HOME` is unset, and accepts explicit paths as independent overrides. Cubin production does not need a GPU or import torch; run it without importing torch first. Build the native plugin with a TensorRT 11 SDK, CUDA toolkit, CMake, and a C++17 compiler. Inspect the resulting bundle or wheel with `tensoracle.bundle`. The [cubin plugin example](https://github.com/sync-dev-org/tensoracle/tree/main/examples/cubin_plugin) covers rebuilding from a repository clone, packaging, and runtime use. Normal import, engine building, and engine reuse do not import the producer or Triton, and do not need the producer extra or native build tools.
+`tensoracle.producer.compile_bundle` uses Triton 3.8.0, `ptxas >=13.2,<14`, and `cuobjdump` from the extra's PyPI wheels to produce cubins for sm86, sm89, and sm120. The extra declares `nvidia-cuda-nvcc`, `nvidia-cuda-cuobjdump`, `nvidia-cuda-crt`, and `nvidia-nvvm` in the 13.2 series. The producer ignores `CUDA_HOME` and accepts explicit tool paths as independent overrides. A missing tool identifies the wheel and searched path and explains how to install the extra or pass a path. Cubin production does not need a GPU or import torch; run it without importing torch first.
+
+Build the native plugin with a TensorRT 11 SDK, CMake, a C++17 compiler, and PyPI `nvidia-cuda-nvcc==13.2.*` and `nvidia-cuda-runtime==13.2.*`. Pass their `site-packages/nvidia/cu13` directory as `CUDAToolkit_ROOT`, through CMake or the environment. The helper uses the wheel's `cuda.h` and the NVIDIA driver's `libcuda.so` on Linux (including WSL), or the wheel's `lib/x64/cuda.lib` on Windows. Neither workflow needs an OS-installed CUDA Toolkit. TensorRT headers are supplied separately using [Prepare a TensorRT SDK](tensorrt-sdk.md), which also gives the PyPI CUDA setup commands. Inspect the resulting bundle or wheel with `tensoracle.bundle`. The [cubin plugin example](https://github.com/sync-dev-org/tensoracle/tree/main/examples/cubin_plugin) covers rebuilding from a repository clone, packaging, and runtime use. Normal import, engine building, and engine reuse do not import the producer or Triton, and do not need the producer extra or native build tools.
 
 Pass a `tensoracle::cubin::PluginIO` declaration as the fourth argument to `PluginBase(name, plugin_namespace, fields, io)`. The `inputs` vector determines the input count and declares each input's TensorRT `type` and `format` through `TensorSpec`; `output` declares the single output's type and format. `shape_input_index` selects the input whose shape the output copies. This example declares two fp16 / HWC8 inputs and an fp16 / HWC8 output with input 0's shape:
 

{tensoracle-1.2.0 → tensoracle-1.3.0}/docs/tensorrt-sdk.md

@@ -1,6 +1,6 @@
 # Prepare a TensorRT SDK
 
-Use the Linux procedure below to prepare the headers and `libnvinfer` needed to build a native cubin plugin on Linux x86_64, including WSL2. For Windows x86_64, use the [Windows procedure](#windows-x86_64). The Linux SDK root contains 13 headers in `include/`, `lib/libnvinfer.so.11`, and a relative `lib/libnvinfer.so` symlink pointing to `libnvinfer.so.11`. The CUDA toolkit, CMake, and a C++17 compiler are separate build prerequisites. Normal engine reuse does not need this SDK root.
+Use the Linux procedure below to prepare the headers and `libnvinfer` needed to build a native cubin plugin on Linux x86_64, including WSL2. For Windows x86_64, use the [Windows procedure](#windows-x86_64). The Linux SDK root contains 13 headers in `include/`, `lib/libnvinfer.so.11`, and a relative `lib/libnvinfer.so` symlink pointing to `libnvinfer.so.11`. CMake, a C++17 compiler, and the CUDA headers from PyPI are separate build prerequisites; no OS-installed CUDA Toolkit is required. TensorRT headers are absent from the Python wheels and must be prepared separately. Normal engine reuse does not need this SDK root.
 
 The inputs below are fixed for SDK **11.2.1.2**: headers from a release commit of [NVIDIA TensorRT OSS](https://github.com/NVIDIA/TensorRT), and the exact `tensorrt-cu13-libs` wheel from [NVIDIA's package index](https://pypi.nvidia.com/tensorrt-cu13-libs/). The wheel platform is `manylinux_2_28_x86_64`; use that file rather than an aarch64 or Windows wheel.
 
@@ -98,14 +98,23 @@ The SONAME identifies only the major version. Matching `libnvinfer.so.11` does n
 
 ## 5. Pass the verified root to the build and tests
 
-Keep `TENSORRT_ROOT` set to the absolute path of the verified `sdk` directory. From the tensoracle repository root, build the example wheel and pass the same root to its tests:
+Keep `TENSORRT_ROOT` set to the absolute path of the verified `sdk` directory. From the tensoracle repository root, install the producer extra into the development environment and locate its PyPI CUDA root. The lock selects `nvidia-cuda-nvcc` and `nvidia-cuda-runtime` 13.2.86. For a separate build environment, install `nvidia-cuda-nvcc==13.2.*` and `nvidia-cuda-runtime==13.2.*` with that environment's package manager and locate `nvidia/cu13` in the same way.
 
 ```bash
-CMAKE_ARGS="-DTENSORRT_ROOT=$TENSORRT_ROOT" uv build examples/cubin_plugin --wheel
-TENSORACLE_SDK_ROOT="$TENSORRT_ROOT" uv run --project python pytest -q python/tests/test_example_plugin.py
+uv sync --project python --extra producer
+export CUDAToolkit_ROOT="$(uv run --project python --extra producer python -c 'from importlib.metadata import distribution; print(distribution("nvidia-cuda-runtime").locate_file("nvidia/cu13"))')"
+cmake -S cpp -B build/cpp -DCMAKE_BUILD_TYPE=Release \
+  "-DTENSORRT_ROOT=$TENSORRT_ROOT" "-DCUDAToolkit_ROOT=$CUDAToolkit_ROOT"
+cmake --build build/cpp
+ctest --test-dir build/cpp --output-on-failure
+uv build examples/cubin_plugin --wheel \
+  "--config-setting=cmake.define.TENSORRT_ROOT=$TENSORRT_ROOT" \
+  "--config-setting=cmake.define.CUDAToolkit_ROOT=$CUDAToolkit_ROOT"
+TENSORACLE_SDK_ROOT="$TENSORRT_ROOT" TENSORACLE_CUDA_ROOT="$CUDAToolkit_ROOT" \
+  uv run --project python --extra producer pytest -q python/tests/test_example_plugin.py
 ```
 
-The tests also need the CUDA toolkit; tests marked `gpu` require an NVIDIA GPU and driver. The SDK is a build input. The application still selects the TensorRT runtime and verifies its own plugin with that runtime.
+The native helper reads `cuda.h` from this root and links the installed NVIDIA driver's `libcuda.so`; on WSL it searches `/usr/lib/wsl/lib`. It prints the selected headers and driver library during configuration. `CUDAToolkit_ROOT` can also be passed through the environment. Existing OS Toolkit roots and the default search through `nvcc` on `PATH` and `/usr/local/cuda` remain supported. Tests marked `gpu` require an NVIDIA GPU and driver. The SDK is a build input. The application still selects the TensorRT runtime and verifies its own plugin with that runtime.
 
 ## Use another TensorRT 11 release
 
@@ -115,7 +124,7 @@ Use the same acquisition and verification steps for another TensorRT 11 release,
 
 Use NVIDIA's official Windows ZIP to obtain both the headers and the MSVC import library. The TensorRT runtime wheel supplies DLLs, but it does not replace the SDK's `include/` directory and `lib/nvinfer_11.lib`. See NVIDIA's [Windows ZIP installation guide](https://docs.nvidia.com/deeplearning/tensorrt/latest/installing-tensorrt/install-zip.html) and [TensorRT 11 downloads](https://developer.nvidia.com/tensorrt/download/11x).
 
-The following inputs are fixed for **11.4.0.106**, Windows amd64, CUDA 13.4. Use Visual Studio 2022 with MSVC, CMake, Ninja, and a CUDA toolkit available in an **x64 Native Tools Command Prompt for VS 2022**, then start PowerShell from that prompt. The example below selects CUDA toolkit 12.8 as a build input; tensoracle's Python runtime dependencies select the CUDA 13 TensorRT runtime separately. Do not combine Windows import libraries with Linux shared libraries.
+The following inputs are fixed for **11.4.0.106**, Windows amd64, CUDA 13.4. Use Visual Studio 2022 with MSVC, CMake, and Ninja available in an **x64 Native Tools Command Prompt for VS 2022**, then start PowerShell from that prompt. The CUDA build inputs below come from PyPI's 13.2 wheels; an OS-installed CUDA Toolkit is not needed. tensoracle's Python runtime dependencies select the CUDA 13 TensorRT runtime separately. Do not combine Windows import libraries with Linux shared libraries.
 
 Choose a new workspace. The command creating it must fail if the directory already exists. Download the fixed ZIP, record its digest, and extract it without installing software system-wide:
 
@@ -180,7 +189,14 @@ From the tensoracle repository root, configure and test the standalone C++ proje
 
 ```powershell
 $env:TENSORACLE_SDK_ROOT = $env:TENSORRT_ROOT
-$env:TENSORACLE_CUDA_ROOT = 'C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v12.8'
+uv sync --project python
+if ($LASTEXITCODE) { throw 'Development environment setup failed' }
+uv pip install --python python/.venv/Scripts/python.exe `
+    'nvidia-cuda-nvcc==13.2.*' 'nvidia-cuda-runtime==13.2.*'
+if ($LASTEXITCODE) { throw 'PyPI CUDA installation failed' }
+$env:CUDAToolkit_ROOT = (& python/.venv/Scripts/python.exe -c 'from importlib.metadata import distribution; print(distribution("nvidia-cuda-runtime").locate_file("nvidia/cu13"))')
+if ($LASTEXITCODE) { throw 'PyPI CUDA root lookup failed' }
+$env:TENSORACLE_CUDA_ROOT = $env:CUDAToolkit_ROOT
 cmake -S cpp -B build/windows -G Ninja -DCMAKE_BUILD_TYPE=Release `
     "-DTENSORRT_ROOT=$env:TENSORRT_ROOT" "-DCUDAToolkit_ROOT=$env:TENSORACLE_CUDA_ROOT"
 if ($LASTEXITCODE) { throw 'CMake configuration failed' }
@@ -196,4 +212,4 @@ uv run --project python pytest python/tests/test_example_plugin.py
 if ($LASTEXITCODE) { throw 'Example plugin tests failed' }
 ```
 
-The example build uses `cpp/cmake/TensoracleCubinPlugin.cmake`, which finds `nvinfer_11.lib` in the SDK's `lib/` directory. The built plugin is a DLL. Keep its TensorRT runtime available through the application's installed Python dependencies; the SDK directory is a build input and does not need to be added to the runtime `PATH`. For another TensorRT 11 release, establish new expected digests and check that release's exact header version before building.
+The example build uses `cpp/cmake/TensoracleCubinPlugin.cmake`, which finds `nvinfer_11.lib` in the SDK's `lib/` directory, `cuda.h` in the PyPI root's `include/`, and the CUDA driver import library at `lib/x64/cuda.lib` in that root. The built plugin is a DLL. Keep its TensorRT runtime available through the application's installed Python dependencies; the SDK directory is a build input and does not need to be added to the runtime `PATH`. For another TensorRT 11 release, establish new expected digests and check that release's exact header version before building.

{tensoracle-1.2.0 → tensoracle-1.3.0}/examples/cubin_plugin/README.md

@@ -6,13 +6,13 @@ The first plugin computes an fp32 32 by 16 dot product and then scales it in a s
 
 ## Rebuild the cubins
 
-Provide a CUDA toolkit with `ptxas >=13.2,<14` and `cuobjdump`. Set `CUDA_HOME` to its directory; when unset, the producer uses `/usr/local/cuda`. From the tensoracle repository root, run:
+The producer extra supplies Triton 3.8.0 and the PyPI CUDA tools, including `ptxas >=13.2,<14` and `cuobjdump`. No OS-installed CUDA Toolkit is required. From the tensoracle repository root, run:
 
 ```bash
 uv run --project python --extra producer python -c 'from pathlib import Path; from examples.cubin_plugin.kernels import kernel_specs; from tensoracle.producer import compile_bundle; compile_bundle(kernel_specs(), Path("examples/cubin_plugin/bundle"))'
 ```
 
-This installs Triton 3.8.0 with `tensoracle[producer]` and recreates `bundle/` with the host toolkit tools without using a GPU. Explicit `ptxas` and `cuobjdump` paths passed to `compile_bundle` override the toolkit defaults independently. The producer checks the cubin ELF SM, public and hidden argument layout, register count, and zero scratch sizes before writing the manifest. Run the tests below with the producer extra alone so torch is absent; `compile_bundle` rejects an already imported torch.
+This installs Triton 3.8.0 and the 13.2 series of `nvidia-cuda-nvcc`, `nvidia-cuda-cuobjdump`, `nvidia-cuda-crt`, and `nvidia-nvvm` with `tensoracle[producer]`, then recreates `bundle/` without using a GPU. The tools come from `nvidia/cu13/bin/` in the installed wheels, and `CUDA_HOME` is ignored. Explicit `ptxas` and `cuobjdump` paths passed to `compile_bundle` override the wheel defaults independently. The producer checks the cubin ELF SM, public and hidden argument layout, register count, and zero scratch sizes before writing the manifest. Run the tests below with the producer extra alone so torch is absent; `compile_bundle` rejects an already imported torch.
 
 Check that the generated bundle has the expected files and passes inspection without using a GPU:
 
@@ -20,26 +20,31 @@ Check that the generated bundle has the expected files and passes inspection wit
 uv run --project python --extra producer pytest -m "not gpu" python/tests/test_producer.py
 ```
 
-Without Triton or the toolkit tools, the compilation tests skip with an explanation of what is missing.
+Without Triton or the wheel tools, the compilation tests skip with an explanation of what is missing.
 
 ## Build and inspect the wheel
 
 Follow [Prepare a TensorRT SDK](../../docs/tensorrt-sdk.md) to obtain and verify the headers and library, then set `TENSORRT_ROOT` to that TensorRT 11 SDK containing `include/NvInfer.h` and a `lib` directory. The procedure supplies fixed inputs for SDK 11.2.1.2 and explains how to verify other TensorRT 11 releases. The example has been built against SDK 11.0.0.114, 11.1.0.106, 11.2.1.2, 11.3.0.99, and 11.4.0.106 and run on sm86, sm89, and sm120; see the [tested environments](../../README.md#tested-environments). `TENSORACLE_CPP_ROOT` may point to the `cpp` directory inside an installed tensoracle wheel; when building from this repository it defaults to `../../cpp`.
 
 ```bash
-CMAKE_ARGS="-DTENSORRT_ROOT=$TENSORRT_ROOT" uv build examples/cubin_plugin --wheel
+uv sync --project python --extra producer
+export CUDAToolkit_ROOT="$(uv run --project python --extra producer python -c 'from importlib.metadata import distribution; print(distribution("nvidia-cuda-runtime").locate_file("nvidia/cu13"))')"
+uv build examples/cubin_plugin --wheel \
+  "--config-setting=cmake.define.TENSORRT_ROOT=$TENSORRT_ROOT" \
+  "--config-setting=cmake.define.CUDAToolkit_ROOT=$CUDAToolkit_ROOT"
 ```
 
-The example's build backend and CUDA tooling belong to this project, not to tensoracle's runtime dependencies. Before installation, inspect the wheel with `tensoracle.bundle.inspect_wheel(wheel, plugin="example_cubin_plugin/libtensoracle_example_plugin.so")`. For a wheel built on Windows, pass `plugin="example_cubin_plugin/tensoracle_example_plugin.dll"`. This compares the library's embedded digest and cubin bytes with the manifest and cubin files.
+The native build uses the PyPI `nvidia-cuda-nvcc` and `nvidia-cuda-runtime` 13.2 root's `cuda.h` and the NVIDIA driver's `libcuda.so` on Linux, including WSL. Windows builds use the wheel's `lib/x64/cuda.lib`; follow the SDK guide's Windows commands to prepare that environment without the Linux-only Triton producer. Neither build needs an OS-installed CUDA Toolkit. The example's build backend and CUDA tooling belong to this project, not to tensoracle's runtime dependencies. Before installation, inspect the wheel with `tensoracle.bundle.inspect_wheel(wheel, plugin="example_cubin_plugin/libtensoracle_example_plugin.so")`. For a wheel built on Windows, pass `plugin="example_cubin_plugin/tensoracle_example_plugin.dll"`. This compares the library's embedded digest and cubin bytes with the manifest and cubin files.
 
 Install the tensoracle wheel and this example wheel into a runtime Python environment with TensorRT 11 and `cuda-python`, but without Triton, torch, or the TensorRT SDK. `open_engine` registers the library before calling `graph` or opening a saved engine. The tests use two separate processes and an `XDG_CACHE_HOME` directory to verify that the second process reuses the saved engine without building a graph.
 
 ## Test on each GPU generation
 
-Run from the tensoracle repository with the SDK and CUDA toolkit paths set. The GPU tests build the example wheel, install it in a temporary runtime environment, and run dynamic shapes, direct builds, saved engine reuse, simultaneous execution in two distinct CUDA contexts, and an fp32 versus TF32 control. Each GPU subprocess has a 50 second limit.
+Run from the tensoracle repository with the SDK and PyPI CUDA root paths set. The GPU tests build the example wheel, install it in a temporary runtime environment, and run dynamic shapes, direct builds, saved engine reuse, simultaneous execution in two distinct CUDA contexts, and an fp32 versus TF32 control. Each GPU subprocess has a 50 second limit.
 
 ```bash
-TENSORACLE_SDK_ROOT="$TENSORRT_ROOT" uv run --project python pytest -q python/tests/test_example_plugin.py
+TENSORACLE_SDK_ROOT="$TENSORRT_ROOT" TENSORACLE_CUDA_ROOT="$CUDAToolkit_ROOT" \
+  uv run --project python pytest -q python/tests/test_example_plugin.py
 ```
 
 Record the GPU name, SM, TensorRT runtime version, test result, and wheel digest on sm86, sm89, and sm120 separately. The code and wheel contain all three cubin generations; successful execution on one generation does not establish the other two.

{tensoracle-1.2.0 → tensoracle-1.3.0}/pyproject.toml

@@ -31,7 +31,13 @@ issues = "https://github.com/sync-dev-org/tensoracle/issues"
 
 [project.optional-dependencies]
 convert = ["torch>=2.6"]
-producer = ["triton==3.8.0"]
+producer = [
+    "triton==3.8.0",
+    "nvidia-cuda-nvcc==13.2.*",
+    "nvidia-cuda-cuobjdump==13.2.*",
+    "nvidia-cuda-crt==13.2.*",
+    "nvidia-nvvm==13.2.*",
+]
 
 [build-system]
 requires = ["hatchling", "hatch-vcs"]

{tensoracle-1.2.0 → tensoracle-1.3.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.2.0'
-__version_tuple__ = version_tuple = (1, 2, 0)
+__version__ = version = '1.3.0'
+__version_tuple__ = version_tuple = (1, 3, 0)
 
 __commit_id__ = commit_id = None

{tensoracle-1.2.0 → tensoracle-1.3.0}/src/tensoracle/producer.py

@@ -1,6 +1,6 @@
 """Compile pinned Triton kernels into a portable cubin bundle.
 
-Install tensoracle[producer] to supply Triton and use a host CUDA toolkit for its tools.
+Install tensoracle[producer] to supply Triton and the NVIDIA wheel tools.
 Importing tensoracle for inference never imports this module or Triton.
 """
 
@@ -10,6 +10,7 @@ import re
 import subprocess
 import sys
 from dataclasses import dataclass, field
+from importlib.metadata import PackageNotFoundError, distribution
 from pathlib import Path
 from typing import Any
 
@@ -27,13 +28,16 @@ class KernelSpec:
     divisible_by: dict[str, int] = field(default_factory=dict)
 
 
-def _toolkit_tool(tool: str) -> Path:
-    path = Path(os.environ.get("CUDA_HOME", "/usr/local/cuda")) / "bin" / tool
+def _wheel_tool(package: str, tool: str) -> Path:
+    suffix = ".exe" if sys.platform == "win32" else ""
+    relative = f"nvidia/cu13/bin/{tool}{suffix}"
+    remedy = f"install it with pip install 'tensoracle[producer]' or pass {tool}=... explicitly"
+    try:
+        path = Path(distribution(package).locate_file(relative))
+    except PackageNotFoundError as exc:
+        raise ImportError(f"{tool} requires {package} at {relative}; {remedy}") from exc
     if not path.is_file():
-        raise FileNotFoundError(
-            f"{tool} was not found at {path}; set CUDA_HOME to a CUDA toolkit "
-            f"or pass {tool}=... explicitly"
-        )
+        raise FileNotFoundError(f"{tool} was not found in the {package} wheel at {path}; {remedy}")
     return path
 
 
@@ -98,8 +102,8 @@ def compile_bundle(
 ) -> dict:
     """Produce and inspect sm86, sm89, and sm120 cubins without importing torch.
 
-    Omitted tool paths use the CUDA toolkit in CUDA_HOME, or /usr/local/cuda if unset.
-    The toolkit must provide ptxas >=13.2,<14 and cuobjdump.
+    Omitted tool paths use the NVIDIA wheels installed by tensoracle[producer].
+    ptxas must be >=13.2,<14. CUDA_HOME is not used.
     Explicit ptxas and cuobjdump paths override those defaults independently.
     """
     if "torch" in sys.modules:
@@ -115,9 +119,9 @@ def compile_bundle(
     if triton.__version__ != "3.8.0":
         raise ValueError(f"Triton 3.8.0 is required, got {triton.__version__}")
     if ptxas is None:
-        ptxas = _toolkit_tool("ptxas")
+        ptxas = _wheel_tool("nvidia-cuda-nvcc", "ptxas")
     if cuobjdump is None:
-        cuobjdump = _toolkit_tool("cuobjdump")
+        cuobjdump = _wheel_tool("nvidia-cuda-cuobjdump", "cuobjdump")
     version = _ptxas_version(ptxas)
     if not (13, 2, 0) <= tuple(map(int, version.split("."))) < (14, 0, 0):
         raise ValueError(f"ptxas >=13.2,<14 is required, got {version}")

tensoracle-1.3.0/tests/cubin_io/kernels.cu

@@ -0,0 +1,17 @@
+// Use half-precision PTX directly so the fixture needs no CCCL headers.
+__device__ unsigned short half_add(unsigned short left, unsigned short right)
+{
+    unsigned short result;
+    asm("add.rn.f16 %0, %1, %2;" : "=h"(result) : "h"(left), "h"(right));
+    return result;
+}
+
+// All tensors use the same packed HWC8 storage. Channels are padded by the caller.
+extern "C" __global__ void half_io(unsigned short const* x, unsigned short const* residual,
+    unsigned short* output, int count, int mode)
+{
+    int index = blockIdx.x * blockDim.x + threadIdx.x;
+    if (index >= count) return;
+    output[index] = mode == 0 ? half_add(x[index], x[index])
+        : mode == 1 ? half_add(x[index], residual[index]) : residual[index];
+}

{tensoracle-1.2.0 → tensoracle-1.3.0}/tests/native/CMakeLists.txt

@@ -2,10 +2,15 @@ cmake_minimum_required(VERSION 3.20)
 project(tensoracle_test_fixtures LANGUAGES C CXX)
 
 if(TEST_CUBIN_SOURCE)
-    find_package(CUDAToolkit REQUIRED)
+    include("${TENSORACLE_CPP_ROOT}/cmake/TensoracleCuda.cmake")
+    _tensoracle_find_cuda()
+    set(_nvcc "${_tensoracle_cuda_root}/bin/nvcc${CMAKE_EXECUTABLE_SUFFIX}")
+    if(NOT EXISTS "${_nvcc}")
+        message(FATAL_ERROR "nvcc is missing at ${_nvcc}; install PyPI nvidia-cuda-nvcc 13.2")
+    endif()
     set(_cubin "${CMAKE_CURRENT_BINARY_DIR}/kernel.cubin")
     add_custom_command(OUTPUT "${_cubin}"
-        COMMAND "${CUDAToolkit_NVCC_EXECUTABLE}" --cubin "-arch=sm_${TEST_CUDA_ARCH}"
+        COMMAND "${_nvcc}" --cubin "-arch=sm_${TEST_CUDA_ARCH}"
             "${TEST_CUBIN_SOURCE}" -o "${_cubin}"
         DEPENDS "${TEST_CUBIN_SOURCE}"
         VERBATIM)
@@ -31,11 +36,12 @@ target_include_directories(${TEST_TARGET} PRIVATE
     "${CMAKE_CURRENT_SOURCE_DIR}" ${TEST_INCLUDE_DIRS})
 
 if(TENSORACLE_CPP_ROOT)
-    find_package(CUDAToolkit REQUIRED)
+    include("${TENSORACLE_CPP_ROOT}/cmake/TensoracleCuda.cmake")
+    _tensoracle_find_cuda()
     target_sources(${TEST_TARGET} PRIVATE "${TENSORACLE_CPP_ROOT}/src/cubin_plugin.cpp")
     target_include_directories(${TEST_TARGET} PRIVATE
         "${TENSORACLE_CPP_ROOT}/include" "${TENSORRT_ROOT}/include")
-    target_link_libraries(${TEST_TARGET} PRIVATE CUDA::cuda_driver)
+    target_link_libraries(${TEST_TARGET} PRIVATE tensoracle_internal_cuda_driver)
     target_compile_options(${TEST_TARGET} PRIVATE
         $<$<CXX_COMPILER_ID:GNU,Clang>:-Wno-deprecated-declarations>)
 endif()

{tensoracle-1.2.0 → tensoracle-1.3.0}/tests/native_build.py

@@ -1,6 +1,8 @@
 """Build native test fixtures using the host's CMake toolchain and artifact names."""
 
+import os
 import subprocess
+from importlib.metadata import PackageNotFoundError, distribution
 from pathlib import Path
 
 NATIVE = Path(__file__).resolve().parent / "native"
@@ -8,6 +10,16 @@ PROJECT = NATIVE.parents[1]
 ROOT = PROJECT.parent if PROJECT.name == "python" else PROJECT
 
 
+def cuda_root():
+    """Use an explicit test root or the installed PyPI CUDA header directory."""
+    if root := os.environ.get("TENSORACLE_CUDA_ROOT"):
+        return Path(root)
+    try:
+        return Path(distribution("nvidia-cuda-runtime").locate_file("nvidia/cu13"))
+    except PackageNotFoundError:
+        return None
+
+
 def _build(work, definitions):
     build = work / "build"
     commands = [
@@ -61,6 +73,7 @@ def build_cubin(work, source, tools, sm):
     return _build(
         work,
         {
+            "TENSORACLE_CPP_ROOT": (ROOT / "cpp").as_posix(),
             "TEST_CUBIN_SOURCE": source.as_posix(),
             "TEST_CUDA_ARCH": sm,
             "CUDAToolkit_ROOT": cuda.as_posix(),