tensoracle 2.1.0__tar.gz → 2.1.1__tar.gz

{tensoracle-2.1.0 → tensoracle-2.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tensoracle
-Version: 2.1.0
+Version: 2.1.1
 Summary: Build, save, reuse, and execute TensorRT engines from safetensors weights
 Author-Email: minamik <mia@sync.dev>
 License-Expression: MIT

{tensoracle-2.1.0 → tensoracle-2.1.1}/cpp/include/tensoracle/tensoracle.h

@@ -6,7 +6,7 @@
 
 #define TENSORACLE_VERSION_MAJOR 2
 #define TENSORACLE_VERSION_MINOR 1
-#define TENSORACLE_VERSION_PATCH 0
+#define TENSORACLE_VERSION_PATCH 1
 
 #if defined(_WIN32)
 #  if defined(TENSORACLE_BUILDING_LIBRARY)

{tensoracle-2.1.0 → tensoracle-2.1.1}/cpp/src/builder.cpp

@@ -75,6 +75,8 @@ cache_request request_from(const tensoracle_builder_options* options) {
 built_plan build_plan(const cache_request& request, const tensoracle_network_builder& callback) {
     auto weights = load_safetensors(request.weights);
     auto& logger = process_engine_logger();
+    // TensorRT requires the timing cache to outlive the builder using it.
+    std::unique_ptr<nvinfer1::ITimingCache> timing;
     std::unique_ptr<nvinfer1::IBuilder> builder(nvinfer1::createInferBuilder(logger));
     if (!builder) throw std::runtime_error("TensorRT failed to create a builder");
     std::unique_ptr<nvinfer1::INetworkDefinition> network(builder->createNetworkV2(0));
@@ -113,6 +115,16 @@ built_plan build_plan(const cache_request& request, const tensoracle_network_bui
         }
     }
     if (profile) require(profile->isValid() && config->addOptimizationProfile(profile) >= 0, "TensorRT rejected the optimization profile");
+    timing.reset(config->createTimingCache(nullptr, 0));
+    if (!timing) throw std::runtime_error("TensorRT failed to create a timing cache");
+    if (!config->setTimingCache(*timing, false)) throw std::runtime_error("TensorRT rejected the timing cache");
+    // A cold TensorRT build can serialize large zero-filled buffers. Rebuild
+    // with the populated in-memory cache before persisting the plan, releasing
+    // the first plan to avoid retaining both serialized engines at once.
+    {
+        std::unique_ptr<nvinfer1::IHostMemory> warmup(builder->buildSerializedNetwork(*network, *config));
+        if (!warmup) throw std::runtime_error("TensorRT failed to build the serialized engine");
+    }
     std::unique_ptr<nvinfer1::IHostMemory> plan(builder->buildSerializedNetwork(*network, *config));
     if (!plan) throw std::runtime_error("TensorRT failed to build the serialized engine");
     auto* first = static_cast<const uint8_t*>(plan->data());

{tensoracle-2.1.0 → tensoracle-2.1.1}/cpp/tests/builder.cpp

@@ -2,6 +2,7 @@
 #include "builder_internal.hpp"
 #include <tensoracle/cache.hpp>
 #include <catch2/catch_test_macros.hpp>
+#include <chrono>
 #include <cstdio>
 #include <sys/wait.h>
 #include <unistd.h>
@@ -10,6 +11,56 @@
 #endif
 
 using namespace builder_fixture;
+TEST_CASE("Saved LeakyReLU engines stay small and reuse correct half precision outputs", "[SP-TENSORACLE-009][gpu]") {
+    context gpu; temporary_directory files; auto path = files.path / "weights"; write_weights(path);
+    auto request = options(path); request.name = "leaky-relu";
+    request.workspace_limit = 4ULL * 1024 * 1024 * 1024; request.optimization_level = 3;
+    const std::vector<int64_t> dimensions{1, 64, 135, 240};
+    request.inputs = {{"features", dimensions, dimensions, dimensions}};
+    request.io = {{"features", TENSORACLE_FLOAT16, dimensions, true}, {"result", TENSORACLE_FLOAT16, dimensions, false}};
+    int calls = 0;
+    auto define = [&](nvinfer1::INetworkDefinition& network, const tensoracle::weights_view&) {
+        ++calls;
+        auto* input = network.addInput("features", nvinfer1::DataType::kHALF, nvinfer1::Dims4(1, 64, 135, 240));
+        REQUIRE(input);
+        auto* activation = network.addActivation(*input, nvinfer1::ActivationType::kLEAKY_RELU);
+        REQUIRE(activation); activation->setAlpha(0.1f);
+        auto* result = activation->getOutput(0); REQUIRE(result);
+        result->setName("result"); network.markOutput(*result);
+    };
+    auto started = std::chrono::steady_clock::now();
+    auto engine = tensoracle::open_engine(request, define);
+    auto elapsed = std::chrono::duration<double>(std::chrono::steady_clock::now() - started).count();
+    auto bytes = fs::file_size(engine.path());
+    std::printf("LeakyReLU saved bytes=%llu build seconds=%.6f\n", (unsigned long long)bytes, elapsed);
+    // Without a warm timing cache, TensorRT 11.4 serializes about 29 MB for this one layer.
+    CHECK(bytes < 1024 * 1024);
+    REQUIRE(calls == 1);
+
+    // IEEE binary16 values: [-10, -5, -2.5, -1.25, 0, 1, 2, 4].
+    const uint16_t input_pattern[]{0xc900, 0xc500, 0xc100, 0xbd00, 0, 0x3c00, 0x4000, 0x4400};
+    // LeakyReLU(x, 0.1): [-1, -0.5, -0.25, -0.125, 0, 1, 2, 4].
+    const uint16_t output_pattern[]{0xbc00, 0xb800, 0xb400, 0xb000, 0, 0x3c00, 0x4000, 0x4400};
+    const size_t count = 64 * 135 * 240;
+    std::vector<uint16_t> values(count), expected(count), actual(count);
+    for (size_t i = 0; i < count; ++i) {
+        values[i] = input_pattern[i % 8]; expected[i] = output_pattern[i % 8];
+    }
+    device_buffer source(count * sizeof(uint16_t)), target(count * sizeof(uint16_t)); stream queue;
+    cuda_check(cuMemcpyHtoD(source.value, values.data(), count * sizeof(uint16_t)));
+    auto run_activation = [&](const tensoracle::engine_handle& saved) {
+        auto execution = saved.create_execution();
+        execution.enqueue({{"features", reinterpret_cast<void*>(source.value)}, {"result", reinterpret_cast<void*>(target.value)}}, queue.value);
+        cuda_check(cuStreamSynchronize(queue.value));
+        cuda_check(cuMemcpyDtoH(actual.data(), target.value, count * sizeof(uint16_t)));
+        REQUIRE(std::equal(actual.begin(), actual.end(), expected.begin()));
+    };
+    run_activation(engine);
+    auto reopened = tensoracle::open_engine(request, define);
+    REQUIRE(calls == 1); REQUIRE(reopened.path() == engine.path());
+    run_activation(reopened);
+}
+
 TEST_CASE("Public builder retains weights through serialization and reuses ranged named engines", "[SP-TENSORACLE-007][SP-TENSORACLE-008][SP-TENSORACLE-009][SP-TENSORACLE-052][SP-TENSORACLE-059][gpu]") {
     context gpu; temporary_directory files; auto path = files.path / "linear.safetensors"; write_weights(path);
     auto request = options(path, "fp32", true); int calls = 0;

{tensoracle-2.1.0 → tensoracle-2.1.1}/src/tensoracle/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.1.0'
-__version_tuple__ = version_tuple = (2, 1, 0)
+__version__ = version = '2.1.1'
+__version_tuple__ = version_tuple = (2, 1, 1)
 
 __commit_id__ = commit_id = None

{tensoracle-2.1.0 → tensoracle-2.1.1}/tests/native_build.py

@@ -1,6 +1,7 @@
 """Build native test fixtures using the host's CMake toolchain and artifact names."""
 
 import os
+import re
 import subprocess
 from importlib.metadata import PackageNotFoundError, distribution
 from pathlib import Path
@@ -10,6 +11,15 @@ PROJECT = NATIVE.parents[1]
 ROOT = PROJECT.parent if PROJECT.name == "python" else PROJECT
 
 
+def sdk_version():
+    """Read the expected library version from the public SDK header."""
+    header = (ROOT / "cpp/include/tensoracle/tensoracle.h").read_text(encoding="utf-8")
+    return tuple(
+        int(re.search(rf"^#define TENSORACLE_VERSION_{part} (\d+)$", header, re.MULTILINE)[1])
+        for part in ("MAJOR", "MINOR", "PATCH")
+    )
+
+
 def cuda_root():
     """Use an explicit test root or the installed PyPI CUDA header directory."""
     if root := os.environ.get("TENSORACLE_CUDA_ROOT"):

{tensoracle-2.1.0 → tensoracle-2.1.1}/tests/test_distribution.py

@@ -23,7 +23,7 @@ import yaml
 from packaging.requirements import Requirement
 from safetensors.numpy import save_file
 
-from native_build import cuda_root
+from native_build import cuda_root, sdk_version
 
 PROJECT = Path(__file__).resolve().parents[1]
 ROOT = PROJECT.parent if PROJECT.name == "python" else PROJECT
@@ -306,7 +306,7 @@ def test_installed_wheel_serves_python_and_cpp_without_the_source_tree(distribut
             "-c",
             (
                 "from tensoracle import _native; import sysconfig; "
-                "assert _native.version() == (2, 0, 0); "
+                f"assert _native.version() == {sdk_version()!r}; "
                 "assert _native.tensorrt_version()[0] == 11; "
                 "print(sysconfig.get_path('platlib'))"
             ),
@@ -468,7 +468,7 @@ print(json.dumps({'version': _native.version(), 'module': _native.__file__,
                   'site': str(site), 'libraries': sorted(libraries), 'path': sys.path}))
 """,
     )
-    assert installed["version"] == [2, 0, 0]
+    assert installed["version"] == list(sdk_version())
     site = Path(installed["site"])
     assert Path(installed["module"]).parent == site / "tensoracle_consumer"
     assert len(installed["libraries"]) == 1

{tensoracle-2.1.0 → tensoracle-2.1.1}/tests/test_native.py

@@ -5,6 +5,8 @@ from importlib.metadata import distribution
 
 import pytest
 
+from native_build import sdk_version
+
 
 @pytest.mark.req("SP-TENSORACLE-053")
 @pytest.mark.req("SP-TENSORACLE-056")
@@ -12,7 +14,7 @@ def test_native_versions_are_available_without_initializing_cuda():
     """The binding reports tensoracle and TensorRT versions as three integers."""
     from tensoracle import _native
 
-    assert _native.version() == (2, 0, 0)
+    assert _native.version() == sdk_version()
     tensorrt = _native.tensorrt_version()
     assert len(tensorrt) == 3
     assert all(isinstance(value, int) for value in tensorrt)