NvInferSafePlugin.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 1993-2026 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.
 */
 
// Header file for the NVIDIA Safe Runtime PluginV3 interface.
// This file provides the user-implementable interface for the PluginV3 feature in the NVIDIA Safe Runtime.
// It includes the necessary classes, functions, and definitions for creating and managing safe plugins,
// including the ISafePluginResourceContext, ISafePluginRegistry, IPluginV3OneSafeCore, IPluginV3OneSafeBuild,
// IPluginV3OneSafeRuntime, and ISafePluginCreatorV3One interfaces.
// Users should implement these interfaces to create custom plugins that can be used with in the Safe Runtime.
 
#ifndef NV_INFER_SAFE_PLUGIN_H
#define NV_INFER_SAFE_PLUGIN_H
#include "NvInferForwardDecl.h"
#include "NvInferPluginBase.h"
#include "NvInferSafeMemAllocator.h"
#include "NvInferSafeRecorder.h"
 
namespace nvinfer1
{
class DimsExprs;
class IExprBuilder;
} // namespace nvinfer1
 
namespace nvinfer2
{
namespace safe
{
// Forward declaration of TensorDescriptor and RuntimeErrorInformation for the plugin interface classes
struct RuntimeErrorInformation;
struct TensorDescriptor;
 
class ISafePluginResourceContext
{
public:
    virtual ISafeMemAllocator* getSafeMemAllocator() const noexcept = 0;
 
    virtual ISafeRecorder* getSafeRecorder() const noexcept = 0;
 
    virtual RuntimeErrorInformation* getRuntimeErrorInformation() const noexcept = 0;
 
    virtual ~ISafePluginResourceContext() noexcept = default;
 
protected:
    ISafePluginResourceContext() = default;
    ISafePluginResourceContext(ISafePluginResourceContext const&) = default;
    ISafePluginResourceContext(ISafePluginResourceContext&&) = default;
    ISafePluginResourceContext& operator=(ISafePluginResourceContext const&) & = default;
    ISafePluginResourceContext& operator=(ISafePluginResourceContext&&) & = default;
};
 
//
class ISafePluginRegistry
{
public:
    virtual ErrorCode registerCreator(
        IPluginCreatorInterface& creator, AsciiChar const* const pluginNamespace, ISafeRecorder& recorder) noexcept = 0;
 
    virtual ErrorCode getAllCreators(
        IPluginCreatorInterface* const*& creators, int32_t& numCreators) const noexcept = 0;
 
    virtual ErrorCode getCreator(IPluginCreatorInterface*& creator, AsciiChar const* const pluginName,
        AsciiChar const* const pluginVersion, AsciiChar const* const pluginNamespace = "") noexcept = 0;
 
    virtual ErrorCode setSafeRecorder(ISafeRecorder& recorder) noexcept = 0;
 
    virtual ErrorCode getSafeRecorder(ISafeRecorder*& recorder) const noexcept = 0;
 
    virtual ErrorCode deregisterCreator(IPluginCreatorInterface const& creator) noexcept = 0;
 
    // @cond SuppressDoxyWarnings
    ISafePluginRegistry() = default;
    ISafePluginRegistry(ISafePluginRegistry const&) = delete;
    ISafePluginRegistry(ISafePluginRegistry&&) = delete;
    ISafePluginRegistry& operator=(ISafePluginRegistry const&) & = delete;
    ISafePluginRegistry& operator=(ISafePluginRegistry&&) & = delete;
    // @endcond
 
protected:
    virtual ~ISafePluginRegistry() noexcept = default;
};
 
class IPluginV3OneSafeCore : public IPluginCapability
{
public:
    InterfaceInfo getInterfaceInfo() const noexcept override
    {
        return InterfaceInfo{"PLUGIN_V3ONE_SAFE_CORE", 1, 0};
    }
 
    IPluginV3OneSafeCore(IPluginV3OneSafeCore const&) = default;
 
    IPluginV3OneSafeCore(IPluginV3OneSafeCore&&) = default;
 
    IPluginV3OneSafeCore& operator=(IPluginV3OneSafeCore const&) & = default;
 
    IPluginV3OneSafeCore& operator=(IPluginV3OneSafeCore&&) & = default;
 
    ~IPluginV3OneSafeCore() noexcept override = default;
 
    virtual AsciiChar const* getPluginName() const noexcept = 0;
 
    virtual AsciiChar const* getPluginVersion() const noexcept = 0;
 
    virtual AsciiChar const* getPluginNamespace() const noexcept = 0;
 
protected:
    IPluginV3OneSafeCore() = default;
};
 
class IPluginV3OneSafeBuild : public IPluginCapability
{
public:
    static constexpr int32_t kDEFAULT_FORMAT_COMBINATION_LIMIT = 100;
 
    InterfaceInfo getInterfaceInfo() const noexcept override
    {
        return InterfaceInfo{"PLUGIN_V3ONE_SAFE_BUILD", 1, 0};
    }
 
    IPluginV3OneSafeBuild() = default;
    IPluginV3OneSafeBuild(IPluginV3OneSafeBuild&&) = delete;
    IPluginV3OneSafeBuild& operator=(IPluginV3OneSafeBuild&&) & = delete;
    ~IPluginV3OneSafeBuild() noexcept override = default;
 
    virtual int32_t configurePlugin(
        TensorDescriptor const* in, int32_t nbInputs, TensorDescriptor const* out, int32_t nbOutputs) noexcept = 0;
 
    virtual int32_t getOutputDataTypes(
        DataType* outputTypes, int32_t nbOutputs, DataType const* inputTypes, int32_t nbInputs) const noexcept
        = 0;
 
    virtual int32_t getOutputShapes(
        Dims const* inputs, int32_t nbInputs, Dims* outputs, int32_t nbOutputs) const noexcept = 0;
 
    virtual bool supportsFormatCombination(
        int32_t pos, TensorDescriptor const* inOut, int32_t nbInputs, int32_t nbOutputs) noexcept = 0;
 
    virtual int32_t getNbOutputs() const noexcept = 0;
 
    virtual size_t getWorkspaceSize(TensorDescriptor const* /*inputs*/, int32_t /*nbInputs*/,
        TensorDescriptor const* /*outputs*/, int32_t /*nbOutputs*/) const noexcept
    {
        return 0U;
    }
 
    virtual int32_t getValidTactics(int32_t* /*tactics*/, int32_t /*nbTactics*/) noexcept
    {
        return 0;
    }
 
    virtual int32_t getNbTactics() noexcept
    {
        return 0;
    }
 
    virtual char const* getTimingCacheID() noexcept
    {
        return nullptr;
    }
 
    virtual int32_t getFormatCombinationLimit() noexcept
    {
        return kDEFAULT_FORMAT_COMBINATION_LIMIT;
    }
 
    virtual char const* getMetadataString() noexcept
    {
        return nullptr;
    }
 
protected:
    IPluginV3OneSafeBuild(IPluginV3OneSafeBuild const&) = default;
    IPluginV3OneSafeBuild& operator=(IPluginV3OneSafeBuild const&) & = default;
};
 
class IPluginV3OneSafeBuildMSS : public IPluginV3OneSafeBuild
{
public:
    InterfaceInfo getInterfaceInfo() const noexcept override
    {
        return InterfaceInfo{"PLUGIN_V3ONE_SAFE_BUILDMSS", 1, 0};
    }
 
    int32_t getOutputShapes(
        Dims const* /*inputs*/, int32_t /*nbInputs*/, Dims* /*outputs*/, int32_t /*nbOutputs*/) const noexcept override
    {
        // This function will not be used, instead, getSymbolicOutputShapes should be used.
        return 0;
    }
 
    IPluginV3OneSafeBuildMSS(IPluginV3OneSafeBuildMSS const&) = default;
 
    IPluginV3OneSafeBuildMSS(IPluginV3OneSafeBuildMSS&&) = delete;
 
    IPluginV3OneSafeBuildMSS& operator=(IPluginV3OneSafeBuildMSS const&) & = default;
 
    IPluginV3OneSafeBuildMSS& operator=(IPluginV3OneSafeBuildMSS&&) & = delete;
 
    ~IPluginV3OneSafeBuildMSS() noexcept override = default;
    virtual int32_t getSymbolicOutputShapes(nvinfer1::DimsExprs const* inputs, int32_t nbInputs,
        nvinfer1::DimsExprs* outputs, int32_t nbOutputs, nvinfer1::IExprBuilder& exprBuilder) const noexcept = 0;
 
protected:
    IPluginV3OneSafeBuildMSS() = default;
};
 
//
class IPluginV3OneSafeRuntime : public IPluginCapability
{
public:
    InterfaceInfo getInterfaceInfo() const noexcept override
    {
        return InterfaceInfo{"PLUGIN_V3ONE_SAFE_RUNTIME", 1, 0};
    }
 
    IPluginV3OneSafeRuntime(IPluginV3OneSafeRuntime const&) = default;
 
    IPluginV3OneSafeRuntime(IPluginV3OneSafeRuntime&&) = default;
 
    IPluginV3OneSafeRuntime& operator=(IPluginV3OneSafeRuntime const&) & = default;
 
    IPluginV3OneSafeRuntime& operator=(IPluginV3OneSafeRuntime&&) & = default;
 
    ~IPluginV3OneSafeRuntime() noexcept override = default;
 
    virtual int32_t setTactic(int32_t /*tactic*/) noexcept
    {
        return 0;
    }
 
    virtual int32_t enqueue(TensorDescriptor const* inputDesc, TensorDescriptor const* outputDesc,
        void const* const* inputs, void* const* outputs, void* workspace, cudaStream_t stream) noexcept = 0;
 
    virtual int32_t initResource(ISafePluginResourceContext const* context) noexcept = 0;
 
    virtual IPluginV3* clone() noexcept = 0;
 
 
    virtual PluginFieldCollection const* getFieldsToSerialize() noexcept = 0;
 
protected:
    IPluginV3OneSafeRuntime() = default;
};
 
//
class ISafePluginCreatorV3One : public IPluginCreatorInterface
{
public:
    InterfaceInfo getInterfaceInfo() const noexcept override
    {
        return InterfaceInfo{"PLUGIN SAFE CREATOR_V3ONE", 1, 0};
    }
 
    virtual IPluginV3* createPlugin(
        AsciiChar const* name, PluginFieldCollection const* fc, TensorRTPhase phase) noexcept = 0;
 
    virtual PluginFieldCollection const* getFieldNames() noexcept = 0;
 
    virtual AsciiChar const* getPluginName() const noexcept = 0;
 
    virtual AsciiChar const* getPluginVersion() const noexcept = 0;
 
    virtual AsciiChar const* getPluginNamespace() const noexcept = 0;
 
    virtual ISafeRecorder* getSafeRecorder() const noexcept = 0;
 
    virtual void setSafeRecorder(ISafeRecorder&) noexcept = 0;
 
    ISafePluginCreatorV3One() = default;
    ~ISafePluginCreatorV3One() noexcept override = default;
 
protected:
    ISafePluginCreatorV3One(ISafePluginCreatorV3One const&) = default;
    ISafePluginCreatorV3One(ISafePluginCreatorV3One&&) = default;
    ISafePluginCreatorV3One& operator=(ISafePluginCreatorV3One const&) & = default;
    ISafePluginCreatorV3One& operator=(ISafePluginCreatorV3One&&) & = default;
};
 
extern "C" nvinfer2::safe::ISafePluginRegistry* getSafePluginRegistry(nvinfer2::safe::ISafeRecorder& recorder) noexcept;
} // namespace safe
} // namespace nvinfer2
 
#endif /* NV_INFER_SAFE_PLUGIN_H */