NvInferRuntimeBase.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 1993-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: Apache-2.0
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef NV_INFER_RUNTIME_BASE_H
#define NV_INFER_RUNTIME_BASE_H
 
#include "NvInferVersion.h"
#include <cstddef>
#include <cstdint>
#include <cuda_runtime_api.h>
 
// Items that are marked as deprecated will be removed in a future release.
#if __cplusplus >= 201402L
#define TRT_DEPRECATED [[deprecated]]
#if __GNUC__ < 6
#define TRT_DEPRECATED_ENUM
#else
#define TRT_DEPRECATED_ENUM TRT_DEPRECATED
#endif
#ifdef _MSC_VER
#define TRT_DEPRECATED_API __declspec(dllexport)
#else
#define TRT_DEPRECATED_API [[deprecated]] __attribute__((visibility("default")))
#endif
#else
#ifdef _MSC_VER
#define TRT_DEPRECATED
#define TRT_DEPRECATED_ENUM
#define TRT_DEPRECATED_API __declspec(dllexport)
#else
#define TRT_DEPRECATED __attribute__((deprecated))
#define TRT_DEPRECATED_ENUM
#define TRT_DEPRECATED_API __attribute__((deprecated, visibility("default")))
#endif
#endif
 
// Defines which symbols are exported
#ifdef TENSORRT_BUILD_LIB
#ifdef _MSC_VER
#define TENSORRTAPI __declspec(dllexport)
#else
#define TENSORRTAPI __attribute__((visibility("default")))
#endif
#else
#define TENSORRTAPI
#endif
#define TRTNOEXCEPT
#if !defined(NV_INFER_INTERNAL_INCLUDE)
static_assert(false, "Do not directly include this file. Include NvInferRuntime.h or NvInferPluginUtils.h");
#endif
 
 
extern "C"
{
    struct cublasContext;
    struct cudnnContext;
}
 
#define NV_TENSORRT_VERSION_INT(major, minor, patch) ((major) *10000L + (minor) *100L + (patch) *1L)
 
#define NV_TENSORRT_VERSION NV_TENSORRT_VERSION_INT(NV_TENSORRT_MAJOR, NV_TENSORRT_MINOR, NV_TENSORRT_PATCH)
 
namespace nvinfer1
{
using char_t = char;
 
using AsciiChar = char_t;
 
namespace v_1_0
{
class IErrorRecorder;
}
using IErrorRecorder = v_1_0::IErrorRecorder;
 
namespace impl
{
template <typename T>
struct EnumMaxImpl;
} // namespace impl
 
template <typename T>
constexpr int32_t EnumMax() noexcept
{
    return impl::EnumMaxImpl<T>::kVALUE;
}
 
enum class DataType : int32_t
{
    kFLOAT = 0,
 
    kHALF = 1,
 
    kINT8 = 2,
 
    kINT32 = 3,
 
    kBOOL = 4,
 
    kUINT8 = 5,
 
    kFP8 = 6,
 
    kBF16 = 7,
 
    kINT64 = 8,
 
    kINT4 = 9,
 
    kFP4 = 10,
};
 
namespace impl
{
template <>
struct EnumMaxImpl<DataType>
{
    static constexpr int32_t kVALUE = 11;
};
} // namespace impl
 
class Dims64
{
public:
    static constexpr int32_t MAX_DIMS{8};
 
    int32_t nbDims;
 
    int64_t d[MAX_DIMS];
};
 
using Dims = Dims64;
 
using InterfaceKind = char const*;
 
class InterfaceInfo
{
public:
    InterfaceKind kind;
    int32_t major;
    int32_t minor;
};
 
enum class APILanguage : int32_t
{
    kCPP = 0,
    kPYTHON = 1
};
 
namespace impl
{
template <>
struct EnumMaxImpl<APILanguage>
{
    static constexpr int32_t kVALUE = 2;
};
} // namespace impl
 
class IVersionedInterface
{
public:
    virtual APILanguage getAPILanguage() const noexcept
    {
        return APILanguage::kCPP;
    }
 
    virtual InterfaceInfo getInterfaceInfo() const noexcept = 0;
 
    virtual ~IVersionedInterface() noexcept = default;
 
protected:
    IVersionedInterface() = default;
    IVersionedInterface(IVersionedInterface const&) = default;
    IVersionedInterface(IVersionedInterface&&) = default;
    IVersionedInterface& operator=(IVersionedInterface const&) & = default;
    IVersionedInterface& operator=(IVersionedInterface&&) & = default;
};
 
enum class ErrorCode : int32_t
{
    kSUCCESS = 0,
 
    kUNSPECIFIED_ERROR = 1,
 
    kINTERNAL_ERROR = 2,
 
    kINVALID_ARGUMENT = 3,
 
    kINVALID_CONFIG = 4,
 
    kFAILED_ALLOCATION = 5,
 
    kFAILED_INITIALIZATION = 6,
 
    kFAILED_EXECUTION = 7,
 
    kFAILED_COMPUTATION = 8,
 
    kINVALID_STATE = 9,
 
    kUNSUPPORTED_STATE = 10,
 
};
 
namespace impl
{
template <>
struct EnumMaxImpl<ErrorCode>
{
    static constexpr int32_t kVALUE = 11;
};
} // namespace impl
 
namespace v_1_0
{
class IErrorRecorder : public IVersionedInterface
{
public:
    InterfaceInfo getInterfaceInfo() const noexcept override
    {
        return InterfaceInfo{"IErrorRecorder", 1, 0};
    }
 
    using ErrorDesc = char const*;
 
    static constexpr size_t kMAX_DESC_LENGTH{127U};
 
    using RefCount = int32_t;
 
    IErrorRecorder() = default;
    ~IErrorRecorder() noexcept override = default;
 
    // Public API used to retrieve information from the error recorder.
 
    virtual int32_t getNbErrors() const noexcept = 0;
 
    virtual ErrorCode getErrorCode(int32_t errorIdx) const noexcept = 0;
 
    virtual ErrorDesc getErrorDesc(int32_t errorIdx) const noexcept = 0;
 
    virtual bool hasOverflowed() const noexcept = 0;
 
    virtual void clear() noexcept = 0;
 
    // API used by TensorRT to report Error information to the application.
 
    virtual bool reportError(ErrorCode val, ErrorDesc desc) noexcept = 0;
 
    virtual RefCount incRefCount() noexcept = 0;
 
    virtual RefCount decRefCount() noexcept = 0;
 
protected:
    // @cond SuppressDoxyWarnings
    IErrorRecorder(IErrorRecorder const&) = default;
    IErrorRecorder(IErrorRecorder&&) = default;
    IErrorRecorder& operator=(IErrorRecorder const&) & = default;
    IErrorRecorder& operator=(IErrorRecorder&&) & = default;
    // @endcond
}; // class IErrorRecorder
} // namespace v_1_0
 
using IErrorRecorder = v_1_0::IErrorRecorder;
 
enum class TensorIOMode : int32_t
{
    kNONE = 0,
 
    kINPUT = 1,
 
    kOUTPUT = 2
};
 
namespace impl
{
template <>
struct EnumMaxImpl<TensorIOMode>
{
    // Declaration of kVALUE that represents maximum number of elements in TensorIOMode enum
    static constexpr int32_t kVALUE = 3;
};
} // namespace impl
} // namespace nvinfer1
 
extern "C" TENSORRTAPI int32_t getInferLibVersion() noexcept;
 
#endif // NV_INFER_RUNTIME_BASE_H