onnx_bridge.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later
// Copyright 2026 Johnson Ogundeji
#pragma once
 
 
#include "signet/ai/tensor_bridge.hpp"
#include "signet/error.hpp"
 
#include <cstdint>
#include <string>
#include <utility>
#include <vector>
 
namespace signet::forge {
 
enum class OnnxTensorType : int32_t {
    UNDEFINED = 0,    
    FLOAT     = 1,    
    UINT8     = 2,    
    INT8      = 3,    
    UINT16    = 4,    
    INT16     = 5,    
    INT32     = 6,    
    INT64     = 7,    
    STRING    = 8,    
    BOOL      = 9,    
    FLOAT16   = 10,   
    DOUBLE    = 11,   
    UINT32    = 12,   
    UINT64    = 13,   
    BFLOAT16  = 16    
};
 
 
inline OnnxTensorType to_onnx_type(TensorDataType dtype) {
    switch (dtype) {
        case TensorDataType::FLOAT32: return OnnxTensorType::FLOAT;
        case TensorDataType::FLOAT64: return OnnxTensorType::DOUBLE;
        case TensorDataType::INT32:   return OnnxTensorType::INT32;
        case TensorDataType::INT64:   return OnnxTensorType::INT64;
        case TensorDataType::INT8:    return OnnxTensorType::INT8;
        case TensorDataType::UINT8:   return OnnxTensorType::UINT8;
        case TensorDataType::INT16:   return OnnxTensorType::INT16;
        case TensorDataType::FLOAT16: return OnnxTensorType::FLOAT16;
        case TensorDataType::BOOL:    return OnnxTensorType::BOOL;
    }
    return OnnxTensorType::UNDEFINED; // unreachable, silence warnings
}
 
inline expected<TensorDataType> from_onnx_type(OnnxTensorType ort_type) {
    switch (ort_type) {
        case OnnxTensorType::FLOAT:   return TensorDataType::FLOAT32;
        case OnnxTensorType::DOUBLE:  return TensorDataType::FLOAT64;
        case OnnxTensorType::INT32:   return TensorDataType::INT32;
        case OnnxTensorType::INT64:   return TensorDataType::INT64;
        case OnnxTensorType::INT8:    return TensorDataType::INT8;
        case OnnxTensorType::UINT8:   return TensorDataType::UINT8;
        case OnnxTensorType::INT16:   return TensorDataType::INT16;
        case OnnxTensorType::FLOAT16: return TensorDataType::FLOAT16;
        case OnnxTensorType::BOOL:    return TensorDataType::BOOL;
 
        case OnnxTensorType::STRING:
        case OnnxTensorType::UINT16:
        case OnnxTensorType::UINT32:
        case OnnxTensorType::UINT64:
        case OnnxTensorType::BFLOAT16:
        case OnnxTensorType::UNDEFINED:
        default:
            return Error{ErrorCode::UNSUPPORTED_TYPE,
                         "OnnxTensorType has no Signet TensorDataType equivalent"};
    }
}
 
 
struct OnnxTensorInfo {
    void*                  data         = nullptr;   
    std::vector<int64_t>   shape;                    
    OnnxTensorType         element_type = OnnxTensorType::UNDEFINED; 
    size_t                 byte_size    = 0;          
    bool                   is_owner     = false;      
 
    [[nodiscard]] bool is_valid() const {
        return data != nullptr
            && byte_size > 0
            && !shape.empty()
            && element_type != OnnxTensorType::UNDEFINED;
    }
};
 
 
inline expected<OnnxTensorInfo> prepare_for_onnx(const TensorView& tensor) {
    if (!tensor.is_valid()) {
        return Error{ErrorCode::INTERNAL_ERROR,
                     "cannot prepare invalid tensor for ONNX"};
    }
 
    if (!tensor.is_contiguous()) {
        return Error{ErrorCode::UNSUPPORTED_TYPE,
                     "non-contiguous tensors cannot be exported to ONNX; "
                     "call clone() first to produce a contiguous copy"};
    }
 
    // CWE-20: Improper Input Validation — all ONNX dimensions must be positive
    for (auto d : tensor.shape().dims) {
        if (d <= 0) {
            return Error{ErrorCode::INVALID_ARGUMENT,
                         "ONNX tensor dimensions must be positive"};
        }
    }
 
    OnnxTensorInfo info;
    // M28 WARNING: ONNX Runtime requires non-const void*. The caller MUST ensure
    // the source tensor data is not backed by read-only memory (e.g., mmap PROT_READ).
    // If the tensor originates from an mmap'd file, copy it first via OwnedTensor.
    info.data         = const_cast<void*>(tensor.data());
    info.shape        = tensor.shape().dims;
    info.element_type = to_onnx_type(tensor.dtype());
    info.byte_size    = tensor.byte_size();
    info.is_owner     = false; // zero-copy: TensorView owns the data
 
    if (info.element_type == OnnxTensorType::UNDEFINED) {
        return Error{ErrorCode::UNSUPPORTED_TYPE,
                     "tensor dtype maps to UNDEFINED ONNX type"};
    }
 
    return info;
}
 
inline expected<OnnxTensorInfo> prepare_for_onnx(const OwnedTensor& tensor) {
    return prepare_for_onnx(tensor.view());
}
 
 
struct OnnxInputSet {
    std::vector<std::string>     names;    
    std::vector<OnnxTensorInfo>  tensors;  
 
    [[nodiscard]] bool is_valid() const {
        if (names.empty() || names.size() != tensors.size()) return false;
        for (const auto& t : tensors) {
            if (!t.is_valid()) return false;
        }
        return true;
    }
};
 
inline expected<OnnxInputSet> prepare_inputs_for_onnx(
    const std::vector<std::pair<std::string, TensorView>>& inputs)
{
    if (inputs.empty()) {
        return Error{ErrorCode::INTERNAL_ERROR,
                     "cannot prepare empty input set for ONNX"};
    }
 
    OnnxInputSet result;
    result.names.reserve(inputs.size());
    result.tensors.reserve(inputs.size());
 
    for (const auto& [name, tensor] : inputs) {
        auto info = prepare_for_onnx(tensor);
        if (!info) {
            return Error{info.error().code,
                         "failed to prepare ONNX input '" + name + "': "
                         + info.error().message};
        }
        result.names.push_back(name);
        result.tensors.push_back(std::move(*info));
    }
 
    return result;
}
 
inline const char* onnx_type_name(OnnxTensorType t) {
    switch (t) {
        case OnnxTensorType::UNDEFINED: return "UNDEFINED";
        case OnnxTensorType::FLOAT:     return "FLOAT";
        case OnnxTensorType::UINT8:     return "UINT8";
        case OnnxTensorType::INT8:      return "INT8";
        case OnnxTensorType::UINT16:    return "UINT16";
        case OnnxTensorType::INT16:     return "INT16";
        case OnnxTensorType::INT32:     return "INT32";
        case OnnxTensorType::INT64:     return "INT64";
        case OnnxTensorType::STRING:    return "STRING";
        case OnnxTensorType::BOOL:      return "BOOL";
        case OnnxTensorType::FLOAT16:   return "FLOAT16";
        case OnnxTensorType::DOUBLE:    return "DOUBLE";
        case OnnxTensorType::UINT32:    return "UINT32";
        case OnnxTensorType::UINT64:    return "UINT64";
        case OnnxTensorType::BFLOAT16:  return "BFLOAT16";
        default:                        return "UNKNOWN";
    }
}
 
} // namespace signet::forge