tensoracle 2.0.0__tar.gz → 2.1.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tensoracle
-Version: 2.0.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.0.0 → tensoracle-2.1.1}/cpp/include/tensoracle/builder.h

@@ -5,8 +5,10 @@
 extern "C" {
 #endif
 typedef struct tensoracle_weights tensoracle_weights;
-/* Borrowed views into declared safetensors. Values remain valid until the
- * outer open_engine call returns, including after the network callback returns.
+/* Views into safetensors. For owned weights, all names, shapes and values
+ * remain valid until weights_destroy. For borrowed callback weights, they
+ * remain valid until the outer open_engine call returns, including after the
+ * network callback returns.
  * Values are contiguous little-endian scalars; data is naturally aligned.
  * Tensor names must be unique across ALL declared files. A duplicate rejects
  * the build before its callback, identifying the name and both source paths.
@@ -26,6 +28,35 @@ TENSORACLE_API tensoracle_status tensoracle_weights_count(const tensoracle_weigh
 TENSORACLE_API tensoracle_status tensoracle_weights_at(const tensoracle_weights*, size_t, tensoracle_weight*, tensoracle_error**) TENSORACLE_NOEXCEPT;
 TENSORACLE_API tensoracle_status tensoracle_weights_find(const tensoracle_weights*, const char*, tensoracle_weight*, tensoracle_error**) TENSORACLE_NOEXCEPT;
 
+/* Open one safetensors file without initializing CUDA or using a GPU. The same
+ * reader and validation are used by open_engine. On failure *weights is NULL.
+ * Destroy only handles returned by weights_open: NEVER destroy a borrowed
+ * handle supplied to a network callback. Destroy accepts NULL. */
+TENSORACLE_API tensoracle_status tensoracle_weights_open(const char* path, tensoracle_weights** weights, tensoracle_error**) TENSORACLE_NOEXCEPT;
+TENSORACLE_API tensoracle_status tensoracle_weights_destroy(tensoracle_weights*) TENSORACLE_NOEXCEPT;
+
+typedef struct tensoracle_weights_metadata_entry {
+    size_t struct_size;
+    const char* key;
+    size_t key_size;
+    const char* value;
+    size_t value_size;
+} tensoracle_weights_metadata_entry;
+/* Metadata is a map of UTF-8 byte strings, including embedded NUL bytes. Sizes
+ * exclude the additional NUL terminator present after each key/value. Pointers
+ * have the same lifetime as the weight's names and values. Initialize the
+ * output entry's struct_size before reading it.
+ * Missing __metadata__ means an empty map. Indexes enumerate keys in byte
+ * order. Missing keys and out-of-range indexes return INVALID_ARGUMENT.
+ * find accepts a NUL-terminated key; enumerate with at to read keys containing
+ * embedded NUL bytes. Both functions preserve byte lengths in their output.
+ * These operations also accept borrowed network callback weights: metadata
+ * from all declared files is merged, with the first declared file's value
+ * retained for repeated keys. This does not change file validation. */
+TENSORACLE_API tensoracle_status tensoracle_weights_metadata_count(const tensoracle_weights*, size_t*, tensoracle_error**) TENSORACLE_NOEXCEPT;
+TENSORACLE_API tensoracle_status tensoracle_weights_metadata_at(const tensoracle_weights*, size_t, tensoracle_weights_metadata_entry*, tensoracle_error**) TENSORACLE_NOEXCEPT;
+TENSORACLE_API tensoracle_status tensoracle_weights_metadata_find(const tensoracle_weights*, const char*, tensoracle_weights_metadata_entry*, tensoracle_error**) TENSORACLE_NOEXCEPT;
+
 /* network borrows nvinfer1::INetworkDefinition*. Callback/context are borrowed
  * only during this call and never retained. On failure return a nonzero status
  * and optionally a message valid until open_engine returns (literal/context

{tensoracle-2.0.0 → tensoracle-2.1.1}/cpp/include/tensoracle/builder.hpp

@@ -2,9 +2,12 @@
 #include "builder.h"
 #include "engine.hpp"
 #include <exception>
+#include <filesystem>
 #include <optional>
 #include <string>
+#include <string_view>
 #include <type_traits>
+#include <utility>
 #include <vector>
 
 namespace nvinfer1 { class INetworkDefinition; }
@@ -24,9 +27,44 @@ public:
         tensoracle_weight output{}; output.struct_size = sizeof(output); tensoracle_error* error = nullptr;
         auto status = tensoracle_weights_find(value_, name, &output, &error); check(status, error); return output;
     }
+    size_t metadata_size() const {
+        size_t output = 0; tensoracle_error* error = nullptr;
+        auto status = tensoracle_weights_metadata_count(value_, &output, &error); check(status, error); return output;
+    }
+    std::pair<std::string_view, std::string_view> metadata_at(size_t index) const {
+        tensoracle_weights_metadata_entry output{}; output.struct_size = sizeof(output); tensoracle_error* error = nullptr;
+        auto status = tensoracle_weights_metadata_at(value_, index, &output, &error); check(status, error);
+        return {{output.key, output.key_size}, {output.value, output.value_size}};
+    }
+    std::string_view metadata_at(const char* key) const {
+        tensoracle_weights_metadata_entry output{}; output.struct_size = sizeof(output); tensoracle_error* error = nullptr;
+        auto status = tensoracle_weights_metadata_find(value_, key, &output, &error); check(status, error);
+        return {output.value, output.value_size};
+    }
 private:
     const tensoracle_weights* value_;
 };
+
+class weights_handle {
+public:
+    weights_handle() = default;
+    explicit weights_handle(tensoracle_weights* handle) : handle_(handle) {}
+    tensoracle_weights* get() const noexcept { return handle_.get(); }
+    tensoracle_weights* release() noexcept { return handle_.release(); }
+    void close() noexcept { handle_.reset(); }
+    weights_view view() const noexcept { return weights_view(get()); }
+    size_t metadata_size() const { return view().metadata_size(); }
+    std::pair<std::string_view, std::string_view> metadata_at(size_t index) const { return view().metadata_at(index); }
+    std::string_view metadata_at(const char* key) const { return view().metadata_at(key); }
+private:
+    unique_handle<tensoracle_weights, tensoracle_weights_destroy> handle_;
+};
+
+inline weights_handle open_weights(const std::filesystem::path& path) {
+    tensoracle_weights* result = nullptr; tensoracle_error* diagnostic = nullptr;
+    auto status = tensoracle_weights_open(path.string().c_str(), &result, &diagnostic);
+    check(status, diagnostic); return weights_handle(result);
+}
 struct input_profile { std::string name; std::vector<int64_t> minimum, optimum, maximum; };
 struct tensor_spec {
     std::string name; tensoracle_dtype dtype; std::vector<int64_t> shape; bool input;

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

@@ -5,8 +5,8 @@
 #include <stdint.h>
 
 #define TENSORACLE_VERSION_MAJOR 2
-#define TENSORACLE_VERSION_MINOR 0
-#define TENSORACLE_VERSION_PATCH 0
+#define TENSORACLE_VERSION_MINOR 1
+#define TENSORACLE_VERSION_PATCH 1
 
 #if defined(_WIN32)
 #  if defined(TENSORACLE_BUILDING_LIBRARY)

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

@@ -5,6 +5,7 @@
 #include "safetensors.hpp"
 #include "structure.hpp"
 #include <algorithm>
+#include <iterator>
 #include <set>
 #if defined(__GLIBC__)
 #include <malloc.h>
@@ -74,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));
@@ -112,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());
@@ -124,6 +137,47 @@ void write_weight(const tensoracle::detail::weight_record& value, tensoracle_wei
     FIELD(dimensions, value.shape.data()); FIELD(data, value.data()); FIELD(element_count, value.count); FIELD(byte_size, value.bytes);
 #undef FIELD
 }
+void write_metadata(const std::pair<const std::string, std::string>& entry, tensoracle_weights_metadata_entry* output) {
+    fields(output, sizeof(size_t)); auto size = structure_size(output);
+    write_field(output, size, offsetof(tensoracle_weights_metadata_entry, key), entry.first.c_str());
+    write_field(output, size, offsetof(tensoracle_weights_metadata_entry, key_size), entry.first.size());
+    write_field(output, size, offsetof(tensoracle_weights_metadata_entry, value), entry.second.c_str());
+    write_field(output, size, offsetof(tensoracle_weights_metadata_entry, value_size), entry.second.size());
+}
+}
+extern "C" tensoracle_status tensoracle_weights_open(const char* path, tensoracle_weights** output, tensoracle_error** error) noexcept {
+    return tensoracle::detail::guard(error, [&] {
+        if (output) *output = nullptr;
+        require(output, "weights output is required");
+        auto weights = tensoracle::detail::load_safetensors({text(path)});
+        *output = weights.release(); return TENSORACLE_SUCCESS;
+    });
+}
+extern "C" tensoracle_status tensoracle_weights_destroy(tensoracle_weights* weights) noexcept {
+    delete weights;
+    return TENSORACLE_SUCCESS;
+}
+extern "C" tensoracle_status tensoracle_weights_metadata_count(const tensoracle_weights* weights, size_t* count, tensoracle_error** error) noexcept {
+    return tensoracle::detail::guard(error, [&] {
+        if (count) *count = 0;
+        require(weights && count, "weights and metadata count output are required"); *count = weights->metadata.size(); return TENSORACLE_SUCCESS;
+    });
+}
+extern "C" tensoracle_status tensoracle_weights_metadata_at(const tensoracle_weights* weights, size_t index,
+    tensoracle_weights_metadata_entry* output, tensoracle_error** error) noexcept {
+    return tensoracle::detail::guard(error, [&] {
+        require(weights && index < weights->metadata.size(), "metadata index is out of range");
+        auto entry = weights->metadata.begin(); std::advance(entry, index);
+        write_metadata(*entry, output); return TENSORACLE_SUCCESS;
+    });
+}
+extern "C" tensoracle_status tensoracle_weights_metadata_find(const tensoracle_weights* weights, const char* key,
+    tensoracle_weights_metadata_entry* output, tensoracle_error** error) noexcept {
+    return tensoracle::detail::guard(error, [&] {
+        require(weights && key, "weights and metadata key are required");
+        auto entry = weights->metadata.find(key); require(entry != weights->metadata.end(), std::string("unknown weight metadata ") + key);
+        write_metadata(*entry, output); return TENSORACLE_SUCCESS;
+    });
 }
 extern "C" tensoracle_status tensoracle_weights_count(const tensoracle_weights* weights, size_t* count, tensoracle_error** error) noexcept {
     return tensoracle::detail::guard(error, [&] {

{tensoracle-2.0.0 → tensoracle-2.1.1}/cpp/src/safetensors.cpp

@@ -76,6 +76,8 @@ std::unique_ptr<tensoracle_weights> load_safetensors(const std::vector<std::file
             if (name == "__metadata__") {
                 if (!value.is_object()) invalid(path, "metadata must be a string map");
                 for (const auto& entry : value) if (!entry.is_string()) invalid(path, "metadata values must be strings");
+                for (auto entry = value.begin(); entry != value.end(); ++entry)
+                    weights->metadata.emplace(entry.key(), entry.value().get<std::string>());
                 continue;
             }
             if (name.find('\0') != std::string::npos) invalid(path, "tensor name contains NUL");

{tensoracle-2.0.0 → tensoracle-2.1.1}/cpp/src/safetensors.hpp

@@ -27,6 +27,7 @@ struct tensoracle_weights {
     std::vector<std::unique_ptr<tensoracle::detail::mapped_weights_file>> files;
     std::vector<tensoracle::detail::weight_record> tensors;
     std::map<std::string, size_t> names;
+    std::map<std::string, std::string> metadata;
 };
 namespace tensoracle::detail {
 std::unique_ptr<tensoracle_weights> load_safetensors(const std::vector<std::filesystem::path>& paths);

tensoracle-2.1.1/cpp/src/sha256.hpp

@@ -0,0 +1,195 @@
+#pragma once
+#include <array>
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <string>
+
+// Other architectures and MSVC compile only the portable implementation.
+#if (defined(__i386__) || defined(__x86_64__)) && \
+    (defined(__GNUC__) || defined(__clang__)) && !defined(_MSC_VER)
+#include <cpuid.h>
+#include <immintrin.h>
+#define TENSORACLE_DETAIL_SHA256_X86
+#endif
+
+namespace tensoracle::detail {
+inline std::uint32_t rotate_right(std::uint32_t value, unsigned int count) noexcept
+{
+    return (value >> count) | (value << (32U - count));
+}
+inline constexpr std::array<std::uint32_t, 64> sha256_constants{{
+    0x428a2f98U,0x71374491U,0xb5c0fbcfU,0xe9b5dba5U,0x3956c25bU,0x59f111f1U,0x923f82a4U,0xab1c5ed5U,
+    0xd807aa98U,0x12835b01U,0x243185beU,0x550c7dc3U,0x72be5d74U,0x80deb1feU,0x9bdc06a7U,0xc19bf174U,
+    0xe49b69c1U,0xefbe4786U,0x0fc19dc6U,0x240ca1ccU,0x2de92c6fU,0x4a7484aaU,0x5cb0a9dcU,0x76f988daU,
+    0x983e5152U,0xa831c66dU,0xb00327c8U,0xbf597fc7U,0xc6e00bf3U,0xd5a79147U,0x06ca6351U,0x14292967U,
+    0x27b70a85U,0x2e1b2138U,0x4d2c6dfcU,0x53380d13U,0x650a7354U,0x766a0abbU,0x81c2c92eU,0x92722c85U,
+    0xa2bfe8a1U,0xa81a664bU,0xc24b8b70U,0xc76c51a3U,0xd192e819U,0xd6990624U,0xf40e3585U,0x106aa070U,
+    0x19a4c116U,0x1e376c08U,0x2748774cU,0x34b0bcb5U,0x391c0cb3U,0x4ed8aa4aU,0x5b9cca4fU,0x682e6ff3U,
+    0x748f82eeU,0x78a5636fU,0x84c87814U,0x8cc70208U,0x90befffaU,0xa4506cebU,0xbef9a3f7U,0xc67178f2U,
+}};
+
+inline void sha256_compress_portable(std::uint32_t* state, const std::uint8_t* message,
+                                    std::size_t blocks) noexcept {
+    while (blocks--) {
+        std::array<std::uint32_t, 64> words{};
+        for (std::size_t index = 0; index < 16; ++index) {
+            auto const position = index * 4U;
+            words[index] = (static_cast<std::uint32_t>(message[position]) << 24U) |
+                (static_cast<std::uint32_t>(message[position + 1U]) << 16U) |
+                (static_cast<std::uint32_t>(message[position + 2U]) << 8U) |
+                message[position + 3U];
+        }
+        for (std::size_t index = 16; index < 64; ++index) {
+            auto const a = words[index - 15U];
+            auto const b = words[index - 2U];
+            words[index] = words[index - 16U] +
+                (rotate_right(a, 7U) ^ rotate_right(a, 18U) ^ (a >> 3U)) +
+                words[index - 7U] +
+                (rotate_right(b, 17U) ^ rotate_right(b, 19U) ^ (b >> 10U));
+        }
+        auto a = state[0], b = state[1], c = state[2], d = state[3];
+        auto e = state[4], f = state[5], g = state[6], h = state[7];
+        for (std::size_t index = 0; index < 64; ++index) {
+            auto const s1 = rotate_right(e, 6U) ^ rotate_right(e, 11U) ^ rotate_right(e, 25U);
+            auto const choice = (e & f) ^ (~e & g);
+            auto const t1 = h + s1 + choice + sha256_constants[index] + words[index];
+            auto const s0 = rotate_right(a, 2U) ^ rotate_right(a, 13U) ^ rotate_right(a, 22U);
+            auto const majority = (a & b) ^ (a & c) ^ (b & c);
+            auto const t2 = s0 + majority;
+            h = g; g = f; f = e; e = d + t1; d = c; c = b; b = a; a = t1 + t2;
+        }
+        state[0] += a; state[1] += b; state[2] += c; state[3] += d;
+        state[4] += e; state[5] += f; state[6] += g; state[7] += h;
+        message += 64;
+    }
+}
+
+#ifdef TENSORACLE_DETAIL_SHA256_X86
+// Keep SHA/SSSE3 instructions inside this function, including when the header is
+// compiled by a consumer without CPU-specific build flags.
+__attribute__((target("sha,ssse3")))
+inline void sha256_compress_x86(std::uint32_t* state, const std::uint8_t* message,
+                               std::size_t blocks) noexcept {
+    // SHA256RNDS2 packs ABEF and CDGH from the high lane to the low lane.
+    auto abef = _mm_set_epi32(state[0], state[1], state[4], state[5]);
+    auto cdgh = _mm_set_epi32(state[2], state[3], state[6], state[7]);
+    const auto endian = _mm_set_epi8(12, 13, 14, 15, 8, 9, 10, 11,
+                                    4, 5, 6, 7, 0, 1, 2, 3);
+    while (blocks--) {
+        const auto saved_abef = abef, saved_cdgh = cdgh;
+        __m128i words[4];
+        for (std::size_t i = 0; i < 4; ++i)
+            words[i] = _mm_shuffle_epi8(
+                _mm_loadu_si128(reinterpret_cast<const __m128i*>(message + 16 * i)), endian);
+        // A four-vector ring holds W[t-16..t-1]. Each expansion generates four
+        // new words; MSG2 includes the dependencies within those four words.
+#if defined(__clang__)
+#pragma clang loop unroll(full)
+#else
+#pragma GCC unroll 16
+#endif
+        for (std::size_t group = 0; group < 16; ++group) {
+            const auto i = group % 4;
+            if (group >= 4) {
+                auto next = _mm_sha256msg1_epu32(words[i], words[(i + 1) % 4]);
+                next = _mm_add_epi32(next,
+                    _mm_alignr_epi8(words[(i + 3) % 4], words[(i + 2) % 4], 4));
+                words[i] = _mm_sha256msg2_epu32(next, words[(i + 3) % 4]);
+            }
+            auto rounds = _mm_add_epi32(words[i], _mm_loadu_si128(
+                reinterpret_cast<const __m128i*>(sha256_constants.data() + 4 * group)));
+            cdgh = _mm_sha256rnds2_epu32(cdgh, abef, rounds);
+            rounds = _mm_shuffle_epi32(rounds, 0x0e);
+            abef = _mm_sha256rnds2_epu32(abef, cdgh, rounds);
+        }
+        abef = _mm_add_epi32(abef, saved_abef);
+        cdgh = _mm_add_epi32(cdgh, saved_cdgh);
+        message += 64;
+    }
+    std::uint32_t first[4], second[4];
+    _mm_storeu_si128(reinterpret_cast<__m128i*>(first), abef);
+    _mm_storeu_si128(reinterpret_cast<__m128i*>(second), cdgh);
+    state[0] = first[3]; state[1] = first[2]; state[2] = second[3]; state[3] = second[2];
+    state[4] = first[1]; state[5] = first[0]; state[6] = second[1]; state[7] = second[0];
+}
+#endif
+
+enum class sha256_backend { automatic, portable };
+using sha256_compressor = void (*)(std::uint32_t*, const std::uint8_t*, std::size_t) noexcept;
+
+inline sha256_compressor sha256_default_compressor() noexcept {
+    // Resolve once per process rather than querying CPUID for each file or block.
+    static const auto selected = []() noexcept -> sha256_compressor {
+#ifdef TENSORACLE_DETAIL_SHA256_X86
+        unsigned int eax, ebx, ecx, edx;
+        if (__get_cpuid(1, &eax, &ebx, &ecx, &edx) && (ecx & bit_SSSE3) &&
+            __get_cpuid_count(7, 0, &eax, &ebx, &ecx, &edx) && (ebx & (1U << 29)))
+            return sha256_compress_x86;
+#endif
+        return sha256_compress_portable;
+    }();
+    return selected;
+}
+
+// Constant-memory SHA-256, shared with native plugin helpers and cache files.
+class sha256_state {
+public:
+    explicit sha256_state(sha256_backend backend = sha256_backend::automatic) noexcept
+        : compress_(backend == sha256_backend::portable ? sha256_compress_portable
+                                                       : sha256_default_compressor()) {}
+    void update(const void* bytes, std::size_t size) noexcept {
+        if (!size) return;
+        auto* input = static_cast<const std::uint8_t*>(bytes);
+        length_ += size;
+        if (used_) {
+            auto take = std::min(size, block_.size() - used_);
+            std::memcpy(block_.data() + used_, input, take);
+            used_ += take; input += take; size -= take;
+            if (used_ == block_.size()) { compress_(state_.data(), block_.data(), 1); used_ = 0; }
+        }
+        if (size >= block_.size()) {
+            const auto blocks = size / block_.size();
+            compress_(state_.data(), input, blocks);
+            const auto consumed = blocks * block_.size();
+            input += consumed; size -= consumed;
+        }
+        if (size) { std::memcpy(block_.data(), input, size); used_ = size; }
+    }
+    std::string finish() const {
+        auto copy = *this;
+        const auto bits = length_ * 8U;
+        std::uint8_t padding[128]{};
+        padding[0] = 0x80U;
+        auto count = used_ < 56 ? 56 - used_ : 120 - used_;
+        copy.update(padding, count);
+        for (int i = 0; i < 8; ++i) padding[i] = static_cast<std::uint8_t>(bits >> (56 - 8 * i));
+        copy.update(padding, 8);
+        constexpr char hex[] = "0123456789abcdef";
+        std::string result(64U, '0');
+        for (std::size_t word = 0; word < 8; ++word)
+            for (std::size_t nibble = 0; nibble < 8; ++nibble)
+                result[word * 8U + nibble] = hex[(copy.state_[word] >> (4U * (7U - nibble))) & 15U];
+        return result;
+    }
+private:
+    sha256_compressor compress_;
+    std::array<std::uint32_t, 8> state_{{
+        0x6a09e667U,0xbb67ae85U,0x3c6ef372U,0xa54ff53aU,
+        0x510e527fU,0x9b05688cU,0x1f83d9abU,0x5be0cd19U,
+    }};
+    std::array<std::uint8_t, 64> block_{};
+    std::size_t used_ = 0;
+    std::uint64_t length_ = 0;
+};
+inline std::string sha256(void const* bytes, std::size_t size) {
+    sha256_state state;
+    state.update(bytes, size);
+    return state.finish();
+}
+}
+
+#ifdef TENSORACLE_DETAIL_SHA256_X86
+#undef TENSORACLE_DETAIL_SHA256_X86
+#endif

{tensoracle-2.0.0 → tensoracle-2.1.1}/cpp/src/tensoracle.map

@@ -40,3 +40,11 @@ TENSORACLE_2 {
         tensoracle_weights_find;
     local: *;
 };
+TENSORACLE_2.1 {
+    global:
+        tensoracle_weights_open;
+        tensoracle_weights_destroy;
+        tensoracle_weights_metadata_count;
+        tensoracle_weights_metadata_at;
+        tensoracle_weights_metadata_find;
+} TENSORACLE_2;

{tensoracle-2.0.0 → tensoracle-2.1.1}/cpp/tests/CMakeLists.txt

@@ -17,7 +17,7 @@ target_compile_options(tensoracle_c_consumer PRIVATE
     $<$<C_COMPILER_ID:GNU,Clang>:-pedantic-errors;-Wall;-Wextra;-Werror>)
 target_link_libraries(tensoracle_c_consumer PRIVATE tensoracle::tensoracle)
 add_test(NAME "C callers use the ABI without C++ headers" COMMAND tensoracle_c_consumer)
-set_tests_properties("C callers use the ABI without C++ headers" PROPERTIES LABELS "SP-TENSORACLE-014;SP-TENSORACLE-056")
+set_tests_properties("C callers use the ABI without C++ headers" PROPERTIES LABELS "SP-TENSORACLE-014;SP-TENSORACLE-056;SP-TENSORACLE-061")
 
 add_test(NAME "Installed SDK builds a separate C++ application"
     COMMAND "${CMAKE_COMMAND}"

{tensoracle-2.0.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.1/cpp/tests/c_consumer.c

@@ -0,0 +1,76 @@
+#define _POSIX_C_SOURCE 200809L
+/* SP-TENSORACLE-014, SP-TENSORACLE-055, SP-TENSORACLE-056, SP-TENSORACLE-061:
+ * C11 callers compare CPU arrays through the public header. */
+#include <tensoracle/tensoracle.h>
+#include <tensoracle/engine.h>
+#include <tensoracle/plugins.h>
+#include <tensoracle/cache.h>
+#include <tensoracle/builder.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+static int read_weights(void) {
+    char path[] = "/tmp/tensoracle-c-weights-XXXXXX";
+    const char header[] = "{\"__metadata__\":{\"format\":\"test\"},"
+                          "\"bias\":{\"dtype\":\"I8\",\"shape\":[1],\"data_offsets\":[0,1]}}";
+    int fd = mkstemp(path);
+    if (fd < 0) return 10;
+    FILE* file = fdopen(fd, "wb");
+    if (!file) { close(fd); unlink(path); return 11; }
+    uint64_t length = sizeof(header) - 1;
+    for (int i = 0; i < 8; ++i) fputc((int)((length >> (8 * i)) & 255), file);
+    fwrite(header, 1, (size_t)length, file);
+    fputc(7, file);
+    if (fclose(file)) { unlink(path); return 12; }
+    tensoracle_weights* weights = NULL;
+    tensoracle_error* error = NULL;
+    int result = 13;
+    if (tensoracle_weights_open(path, &weights, &error) != TENSORACLE_SUCCESS || error) goto cleanup;
+    size_t count = 0;
+    if (tensoracle_weights_count(weights, &count, &error) != TENSORACLE_SUCCESS || count != 1) goto cleanup;
+    tensoracle_weight tensor = {0}; tensor.struct_size = sizeof(tensor);
+    if (tensoracle_weights_at(weights, 0, &tensor, &error) != TENSORACLE_SUCCESS) goto cleanup;
+    if (strcmp(tensor.name, "bias") || tensor.dtype != TENSORACLE_INT8 || tensor.rank != 1 ||
+        tensor.dimensions[0] != 1 || tensor.element_count != 1 || tensor.byte_size != 1 ||
+        *(const int8_t*)tensor.data != 7) goto cleanup;
+    if (tensoracle_weights_metadata_count(weights, &count, &error) != TENSORACLE_SUCCESS || count != 1) goto cleanup;
+    tensoracle_weights_metadata_entry entry = {0}; entry.struct_size = sizeof(entry);
+    if (tensoracle_weights_metadata_at(weights, 0, &entry, &error) != TENSORACLE_SUCCESS ||
+        entry.key_size != 6 || strcmp(entry.key, "format") || entry.value_size != 4 || strcmp(entry.value, "test")) goto cleanup;
+    if (tensoracle_weights_metadata_find(weights, "format", &entry, &error) != TENSORACLE_SUCCESS ||
+        entry.value_size != 4 || strcmp(entry.value, "test")) goto cleanup;
+    result = 0;
+cleanup:
+    tensoracle_error_destroy(error);
+    tensoracle_weights_destroy(weights);
+    unlink(path);
+    return result;
+}
+
+int main(void) {
+    int weights_result = read_weights();
+    if (weights_result) return weights_result;
+    tensoracle_version version = {sizeof(tensoracle_version), 0, 0, 0};
+    tensoracle_error* error = NULL;
+    tensoracle_cuda_stream stream = NULL;
+    (void)stream;
+    if (tensoracle_cache_result_destroy(NULL) != TENSORACLE_SUCCESS) return 5;
+    tensoracle_engine* unused_engine = NULL;
+    if (tensoracle_open_engine(NULL, NULL, &unused_engine, NULL) != TENSORACLE_INVALID_ARGUMENT || unused_engine) return 6;
+    if (tensoracle_get_version(&version, &error) != TENSORACLE_SUCCESS || error) return 1;
+    if (version.major != TENSORACLE_VERSION_MAJOR) return 2;
+    if (tensoracle_check_version(&version, &error) != TENSORACLE_SUCCESS) return 3;
+    const size_t shape[] = {2};
+    const uint64_t candidate[] = {UINT64_MAX, 1}, reference[] = {UINT64_MAX - 1, 1};
+    const tensoracle_array a = {sizeof(a), TENSORACLE_UINT64, 1, shape, candidate};
+    const tensoracle_array b = {sizeof(b), TENSORACLE_UINT64, 1, shape, reference};
+    tensoracle_output_comparison result = {0};
+    result.struct_size = sizeof(result);
+    if (tensoracle_compare_outputs(&a, &b, NULL, &result, &error) != TENSORACLE_SUCCESS || error)
+        return 5;
+    if (result.available != TENSORACLE_HAS_MISMATCH || result.mismatch_count != 1 ||
+        result.mismatch_fraction != 0.5) return 6;
+    return tensoracle_error_destroy(error) == TENSORACLE_SUCCESS ? 0 : 4;
+}

tensoracle-2.1.1/cpp/tests/utilities.cpp

@@ -0,0 +1,64 @@
+#include "sha256.hpp"
+#include <nlohmann/json.hpp>
+#include <catch2/catch_test_macros.hpp>
+#include <utility>
+
+TEST_CASE("SHA-256 preserves standard digests with automatic and portable processing", "[SP-TENSORACLE-055]") {
+    using tensoracle::detail::sha256;
+    using tensoracle::detail::sha256_backend;
+    // hashlib.sha256 over bytes(i % 251 for i in range(size)), independent of either backend.
+    const std::pair<std::size_t, const char*> vectors[] = {
+        {0, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"},
+        {55, "463eb28e72f82e0a96c0a4cc53690c571281131f672aa229e0d45ae59b598b59"},
+        {56, "da2ae4d6b36748f2a318f23e7ab1dfdf45acdc9d049bd80e59de82a60895f562"},
+        {63, "29af2686fd53374a36b0846694cc342177e428d1647515f078784d69cdb9e488"},
+        {64, "fdeab9acf3710362bd2658cdc9a29e8f9c757fcf9811603a8c447cd1d9151108"},
+        {65, "4bfd2c8b6f1eec7a2afeb48b934ee4b2694182027e6d0fc075074f2fabb31781"},
+        {129, "5099c6a56203f9687f7d33f4bfdf576d31dc91f6b695ecea38b2770c87631135"},
+        {4 * 1024 * 1024 + 17, "7fa1366968edf9a8490fffac3eab7e0b1619480a152d8e75c7471f753a8c1231"},
+    };
+    for (auto backend : {sha256_backend::automatic, sha256_backend::portable}) {
+        CAPTURE(static_cast<int>(backend));
+        for (const auto& [size, expected] : vectors) {
+            CAPTURE(size);
+            // Offset by one byte to exercise unaligned block loads.
+            std::string input(size + 1, '\0');
+            for (std::size_t i = 0; i < size; ++i) input[i + 1] = static_cast<char>(i % 251);
+            tensoracle::detail::sha256_state state(backend);
+            state.update(input.data() + 1, size);
+            REQUIRE(state.finish() == expected);
+            if (backend == sha256_backend::automatic)
+                REQUIRE(sha256(input.data() + 1, size) == expected);
+        }
+        for (const auto& [input, expected] : {
+                std::pair{"abc", "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"},
+                std::pair{"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
+                          "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1"}}) {
+            tensoracle::detail::sha256_state state(backend);
+            state.update(input, std::strlen(input));
+            REQUIRE(state.finish() == expected);
+        }
+    }
+}
+TEST_CASE("Internal JSON supports ordered serialization and UTF-8 metadata", "[SP-TENSORACLE-021]") {
+    auto json = nlohmann::json::parse("{\"z\":[1,2],\"name\":\"重み\"}");
+    REQUIRE(json["name"] == "重み");
+    REQUIRE(json.dump(-1, ' ', true) == "{\"name\":\"\\u91cd\\u307f\",\"z\":[1,2]}");
+}
+
+TEST_CASE("Weight SHA-256 accepts chunks across padding and block boundaries", "[SP-TENSORACLE-009]") {
+    using tensoracle::detail::sha256_backend;
+    std::string input(1000000, 'a');
+    for (auto backend : {sha256_backend::automatic, sha256_backend::portable}) {
+        CAPTURE(static_cast<int>(backend));
+        for (size_t chunk : {size_t(1), size_t(55), size_t(56), size_t(63), size_t(64), size_t(65), size_t(4096)}) {
+            CAPTURE(chunk);
+            tensoracle::detail::sha256_state state(backend);
+            state.update(nullptr, 0);
+            for (size_t i = 0; i < input.size(); i += chunk)
+                state.update(input.data() + i, std::min(chunk, input.size() - i));
+            REQUIRE(state.finish() == "cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0");
+            REQUIRE(state.finish() == tensoracle::detail::sha256(input.data(), input.size()));
+        }
+    }
+}