NvOnnxParser.h

Go to the documentation of this file.

/*
 * Copyright (c) 1993-2022, 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 <vector>
 
 
#define NV_ONNX_PARSER_MAJOR 0
#define NV_ONNX_PARSER_MINOR 1
#define NV_ONNX_PARSER_PATCH 0
 
static const int 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>
inline int32_t EnumMax();
 
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
};
 
template <>
inline int32_t EnumMax<ErrorCode>()
{
    return 9;
}
 
class IParserError
{
public:
    virtual ErrorCode code() const = 0;
    virtual const char* desc() const = 0;
    virtual const char* file() const = 0;
    virtual int line() const = 0;
    virtual const char* func() const = 0;
    virtual int node() 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)
        = 0;
 
    virtual bool parseFromFile(const char* onnxModelFile, int verbosity) = 0;
 
    virtual bool supportsModel(void const* serialized_onnx_model,
                               size_t serialized_onnx_model_size,
                               SubGraphCollection_t& sub_graph_collection,
                               const char* model_path = nullptr)
        = 0;
 
    virtual bool parseWithWeightDescriptors(
        void const* serialized_onnx_model, size_t serialized_onnx_model_size)
        = 0;
 
    virtual bool supportsOperator(const char* op_name) const = 0;
    TRT_DEPRECATED virtual void destroy() = 0;
    virtual int getNbErrors() const = 0;
    virtual IParserError const* getError(int index) const = 0;
    virtual void clearErrors() = 0;
 
    virtual ~IParser() noexcept = default;
};
 
} // namespace nvonnxparser
 
extern "C" TENSORRTAPI void* createNvOnnxParser_INTERNAL(void* network, void* logger, int version);
extern "C" TENSORRTAPI int getNvOnnxParserVersion();
 
namespace nvonnxparser
{
 
namespace
{
 
inline IParser* createParser(nvinfer1::INetworkDefinition& network, nvinfer1::ILogger& logger)
{
    return static_cast<IParser*>(createNvOnnxParser_INTERNAL(&network, &logger, NV_ONNX_PARSER_VERSION));
}
 
} // namespace
 
} // namespace nvonnxparser
 
#endif // NV_ONNX_PARSER_H