NvInferPluginBase.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 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_PLUGIN_BASE_H
#define NV_INFER_PLUGIN_BASE_H
 
#if !defined(NV_INFER_INTERNAL_INCLUDE)
static_assert(false, "Do not directly include this file. Include NvInferRuntime.h or NvInferPluginUtils.h");
#endif
 
#define NV_INFER_INTERNAL_INCLUDE 1
#include "NvInferRuntimeBase.h"
#undef NV_INFER_INTERNAL_INCLUDE
namespace nvinfer1
{
 
enum class PluginFieldType : int32_t
{
    kFLOAT16 = 0,
    kFLOAT32 = 1,
    kFLOAT64 = 2,
    kINT8 = 3,
    kINT16 = 4,
    kINT32 = 5,
    kCHAR = 6,
    kDIMS = 7,
    kUNKNOWN = 8,
    kBF16 = 9,
    kINT64 = 10,
    kFP8 = 11,
    kINT4 = 12,
};
 
class PluginField
{
public:
    AsciiChar const* name;
    void const* data;
    PluginFieldType type;
    int32_t length;
 
    PluginField(AsciiChar const* const name_ = nullptr, void const* const data_ = nullptr,
        PluginFieldType const type_ = PluginFieldType::kUNKNOWN, int32_t const length_ = 0) noexcept
        : name(name_)
        , data(data_)
        , type(type_)
        , length(length_)
    {
    }
};
 
struct PluginFieldCollection
{
    int32_t nbFields{};
    PluginField const* fields{};
};
 
enum class TensorRTPhase : int32_t
{
    kBUILD = 0,
    kRUNTIME = 1
};
 
enum class PluginCapabilityType : int32_t
{
    kCORE = 0,
    kBUILD = 1,
    kRUNTIME = 2
};
 
namespace v_1_0
{
class IPluginCapability : public IVersionedInterface
{
};
 
class IPluginResource : public IVersionedInterface
{
public:
    InterfaceInfo getInterfaceInfo() const noexcept override
    {
        return InterfaceInfo{"IPluginResource", 1, 0};
    }
    virtual int32_t release() noexcept = 0;
 
    virtual IPluginResource* clone() noexcept = 0;
 
    ~IPluginResource() noexcept override = default;
 
    IPluginResource() = default;
    IPluginResource(IPluginResource const&) = default;
    IPluginResource(IPluginResource&&) = default;
    IPluginResource& operator=(IPluginResource const&) & = default;
    IPluginResource& operator=(IPluginResource&&) & = default;
}; // class IPluginResource
 
class IPluginCreatorInterface : public IVersionedInterface
{
public:
    ~IPluginCreatorInterface() noexcept override = default;
 
protected:
    IPluginCreatorInterface() = default;
    IPluginCreatorInterface(IPluginCreatorInterface const&) = default;
    IPluginCreatorInterface(IPluginCreatorInterface&&) = default;
    IPluginCreatorInterface& operator=(IPluginCreatorInterface const&) & = default;
    IPluginCreatorInterface& operator=(IPluginCreatorInterface&&) & = default;
};
 
class IPluginV3 : public IVersionedInterface
{
public:
    InterfaceInfo getInterfaceInfo() const noexcept override
    {
        return InterfaceInfo{"PLUGIN", 1, 0};
    }
 
    virtual IPluginCapability* getCapabilityInterface(PluginCapabilityType type) noexcept = 0;
 
    virtual IPluginV3* clone() noexcept = 0;
};
} // namespace v_1_0
 
using IPluginResource = v_1_0::IPluginResource;
 
using IPluginCreatorInterface = v_1_0::IPluginCreatorInterface;
 
using IPluginV3 = v_1_0::IPluginV3;
 
using IPluginCapability = v_1_0::IPluginCapability;
} // namespace nvinfer1
 
#endif /* NV_INFER_PLUGIN_BASE_H */