NvOnnxParser.h

Go to the documentation of this file.

/*
 * Copyright (c) 1993-2023, NVIDIA CORPORATION. All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */
 
#ifndef NV_ONNX_PARSER_H
#define NV_ONNX_PARSER_H
 
#include "NvInfer.h"
#include <stddef.h>
#include <string>
#include <vector>
 
 
#define NV_ONNX_PARSER_MAJOR 0
#define NV_ONNX_PARSER_MINOR 1
#define NV_ONNX_PARSER_PATCH 0
 
static constexpr int32_t NV_ONNX_PARSER_VERSION
    = ((NV_ONNX_PARSER_MAJOR * 10000) + (NV_ONNX_PARSER_MINOR * 100) + NV_ONNX_PARSER_PATCH);
 
typedef std::pair<std::vector<size_t>, bool> SubGraph_t;
 
typedef std::vector<SubGraph_t> SubGraphCollection_t;
 
namespace nvonnxparser
{
 
template <typename T>
constexpr inline int32_t EnumMax() noexcept;
 
enum class ErrorCode : int
{
    kSUCCESS = 0,
    kINTERNAL_ERROR = 1,
    kMEM_ALLOC_FAILED = 2,
    kMODEL_DESERIALIZE_FAILED = 3,
    kINVALID_VALUE = 4,
    kINVALID_GRAPH = 5,
    kINVALID_NODE = 6,
    kUNSUPPORTED_GRAPH = 7,
    kUNSUPPORTED_NODE = 8,
    kUNSUPPORTED_NODE_ATTR = 9,
    kUNSUPPORTED_NODE_INPUT = 10,
    kUNSUPPORTED_NODE_DATATYPE = 11,
    kUNSUPPORTED_NODE_DYNAMIC = 12,
    kUNSUPPORTED_NODE_SHAPE = 13,
    kREFIT_FAILED = 14
};
 
template <>
constexpr inline int32_t EnumMax<ErrorCode>() noexcept
{
    return 14;
}
 
using OnnxParserFlags = uint32_t;
 
enum class OnnxParserFlag : int32_t
{
    kNATIVE_INSTANCENORM = 0
};
 
template <>
constexpr inline int32_t EnumMax<OnnxParserFlag>() noexcept
{
    return 1;
}
 
class IParserError
{
public:
    virtual ErrorCode code() const = 0;
    virtual char const* desc() const = 0;
    virtual char const* file() const = 0;
    virtual int line() const = 0;
    virtual char const* func() const = 0;
    virtual int node() const = 0;
    virtual char const* nodeName() const = 0;
    virtual char const* nodeOperator() const = 0;
    virtual char const* const* localFunctionStack() const = 0;
    //              a stack size of 0.
    virtual int32_t localFunctionStackSize() const = 0;
 
protected:
    virtual ~IParserError() {}
};
 
class IParser
{
public:
    virtual bool parse(
        void const* serialized_onnx_model, size_t serialized_onnx_model_size, const char* model_path = nullptr) noexcept
        = 0;
 
    virtual bool parseFromFile(const char* onnxModelFile, int verbosity) noexcept = 0;
 
    TRT_DEPRECATED virtual bool supportsModel(void const* serialized_onnx_model, size_t serialized_onnx_model_size,
        SubGraphCollection_t& sub_graph_collection, const char* model_path = nullptr) noexcept = 0;
 
    virtual bool parseWithWeightDescriptors(
        void const* serialized_onnx_model, size_t serialized_onnx_model_size) noexcept
        = 0;
 
    virtual bool supportsOperator(const char* op_name) const noexcept = 0;
 
    virtual int getNbErrors() const noexcept = 0;
 
    virtual IParserError const* getError(int index) const noexcept = 0;
 
    virtual void clearErrors() noexcept = 0;
 
    virtual ~IParser() noexcept = default;
 
    virtual char const* const* getUsedVCPluginLibraries(int64_t& nbPluginLibs) const noexcept = 0;
 
    virtual void setFlags(OnnxParserFlags onnxParserFlags) noexcept = 0;
 
    virtual OnnxParserFlags getFlags() const noexcept = 0;
 
    virtual void clearFlag(OnnxParserFlag onnxParserFlag) noexcept = 0;
 
    virtual void setFlag(OnnxParserFlag onnxParserFlag) noexcept = 0;
 
    virtual bool getFlag(OnnxParserFlag onnxParserFlag) const noexcept = 0;
 
    virtual nvinfer1::ITensor const* getLayerOutputTensor(char const* name, int64_t i) noexcept = 0;
 
    virtual bool supportsModelV2(
        void const* serializedOnnxModel, size_t serializedOnnxModelSize, char const* modelPath = nullptr) noexcept = 0;
 
    virtual int64_t getNbSubgraphs() noexcept = 0;
 
    virtual bool isSubgraphSupported(int64_t const index) noexcept = 0;
 
    virtual int64_t* getSubgraphNodes(int64_t const index, int64_t& subgraphLength) noexcept = 0;
};
 
class IParserRefitter
{
public:
    virtual bool refitFromBytes(
        void const* serializedOnnxModel, size_t serializedOnnxModelSize, char const* modelPath = nullptr) noexcept
        = 0;
 
    virtual bool refitFromFile(char const* onnxModelFile) noexcept = 0;
 
    virtual int32_t getNbErrors() const noexcept = 0;
 
    virtual IParserError const* getError(int32_t index) const noexcept = 0;
 
    virtual void clearErrors() = 0;
 
    virtual ~IParserRefitter() noexcept = default;
};
 
} // namespace nvonnxparser
 
extern "C" TENSORRTAPI void* createNvOnnxParser_INTERNAL(void* network, void* logger, int version) noexcept;
extern "C" TENSORRTAPI void* createNvOnnxParserRefitter_INTERNAL(
    void* refitter, void* logger, int32_t version) noexcept;
extern "C" TENSORRTAPI int getNvOnnxParserVersion() noexcept;
 
namespace nvonnxparser
{
 
namespace
{
 
inline IParser* createParser(nvinfer1::INetworkDefinition& network, nvinfer1::ILogger& logger) noexcept
{
    try
    {
        return static_cast<IParser*>(createNvOnnxParser_INTERNAL(&network, &logger, NV_ONNX_PARSER_VERSION));
    }
    catch (std::exception& e)
    {
        logger.log(nvinfer1::ILogger::Severity::kINTERNAL_ERROR, e.what());
    }
 
    return nullptr;
}
 
inline IParserRefitter* createParserRefitter(nvinfer1::IRefitter& refitter, nvinfer1::ILogger& logger) noexcept
{
    try
    {
        return static_cast<IParserRefitter*>(
            createNvOnnxParserRefitter_INTERNAL(&refitter, &logger, NV_ONNX_PARSER_VERSION));
    }
    catch (std::exception& e)
    {
        logger.log(nvinfer1::ILogger::Severity::kINTERNAL_ERROR, e.what());
    }
 
    return nullptr;
}
 
} // namespace
 
} // namespace nvonnxparser
 
#endif // NV_ONNX_PARSER_H