tensoracle 1.2.0__tar.gz → 1.4.0__tar.gz

tensoracle-1.2.0/README.md → tensoracle-1.4.0/PKG-INFO

@@ -1,3 +1,36 @@
+Metadata-Version: 2.5
+Name: tensoracle
+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
+Project-URL: issues, https://github.com/sync-dev-org/tensoracle/issues
+Author-email: minamik <mia@sync.dev>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: GPU :: NVIDIA CUDA :: 13
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: <3.14,>=3.12
+Requires-Dist: numpy>=2.0
+Requires-Dist: safetensors>=0.4
+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
+
 # tensoracle
 
 Build and execute TensorRT engines from graphs defined with TensorRT's Python network API. The graph function owns the model's safetensors weights and tensor types. Engine building, engine reuse, execution, and output comparison do not require torch. Only the optional `.pth` checkpoint converter requires torch, installed with `tensoracle[convert]`.
@@ -14,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 |
 | --- | --- | --- | --- |
@@ -23,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 |
 
@@ -315,10 +348,32 @@ 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.
 
+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
@@ -366,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.2.0/PKG-INFO → tensoracle-1.4.0/README.md

@@ -1,32 +1,3 @@
-Metadata-Version: 2.5
-Name: tensoracle
-Version: 1.2.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
-Project-URL: issues, https://github.com/sync-dev-org/tensoracle/issues
-Author-email: minamik <mia@sync.dev>
-License-Expression: MIT
-License-File: LICENSE
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Environment :: GPU :: NVIDIA CUDA :: 13
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: Microsoft :: Windows
-Classifier: Operating System :: POSIX :: Linux
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Topic :: Software Development :: Libraries
-Requires-Python: <3.14,>=3.12
-Requires-Dist: numpy>=2.0
-Requires-Dist: safetensors>=0.4
-Requires-Dist: tensorrt-cu13<12,>=11.0
-Provides-Extra: convert
-Requires-Dist: torch>=2.6; extra == 'convert'
-Provides-Extra: producer
-Requires-Dist: triton==3.8.0; extra == 'producer'
-Description-Content-Type: text/markdown
-
 # tensoracle
 
 Build and execute TensorRT engines from graphs defined with TensorRT's Python network API. The graph function owns the model's safetensors weights and tensor types. Engine building, engine reuse, execution, and output comparison do not require torch. Only the optional `.pth` checkpoint converter requires torch, installed with `tensoracle[convert]`.
@@ -43,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 |
 | --- | --- | --- | --- |
@@ -52,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 |
 
@@ -344,10 +315,32 @@ 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.
 
+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
@@ -395,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.2.0 → tensoracle-1.4.0}/cpp/CMakeLists.txt

@@ -5,13 +5,18 @@ 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)
+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.2.0 → tensoracle-1.4.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,13 @@ 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)
+    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.4.0/cpp/cmake/TensoracleCuda.cmake

@@ -0,0 +1,119 @@
+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()
+    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.4.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.4.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.4.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.4.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.4.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.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.2.0'
-__version_tuple__ = version_tuple = (1, 2, 0)
+__version__ = version = '1.4.0'
+__version_tuple__ = version_tuple = (1, 4, 0)
 
 __commit_id__ = commit_id = None