CoreTypes.h

Go to the documentation of this file.

/*
* SPDX-FileCopyrightText: Copyright (c) 2020-2021 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
* SPDX-License-Identifier: MIT
*
* 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 NVNEURAL_CORETYPES_H
#define NVNEURAL_CORETYPES_H
 
#include <cstddef>
#include <cstdint>
#include <tuple>
#include <type_traits>
#include <vector>
#include <initializer_list>
 
 
namespace nvneural {
    class IImage;
    class ILayer;
    class INetwork;
    class INetworkBackend;
    class INetworkRuntime;
    class IPlugin;
    class IPluginLoader;
    class IStringList;
 
    const std::uint32_t ApiVersion = 1338;
 
    enum class TensorDataType : std::uint16_t
    {
        Invalid = 0,           
        TestOnly = 1,          
        Float = 2,             
        Half  = 3,             
        CompressedPng = 7,     
        UncompressedRgb = 8,   
 
        CustomBase = 0x4000u,  
    };
 
    enum class TensorDataLayout : std::uint16_t
    {
        Invalid = 0,           
        TestOnly = 1,          
        Nchw = 2,              
        Nhwc = 3,              
 
        CustomBase = 0x4000u,  
    };
 
    struct TensorFormat
    {
        TensorDataType elementType;    
        TensorDataLayout layout;       
 
        inline TensorFormat()
            : elementType{TensorDataType::Invalid}
            , layout{TensorDataLayout::Invalid}
        {
        }
 
        inline TensorFormat(TensorDataType elementType_, TensorDataLayout layout_)
            : elementType{elementType_}
            , layout{layout_}
        {
        }
 
        inline bool operator !=(const TensorFormat& other) const noexcept
        {
            return elementType != other.elementType
                || layout != other.layout;
        }
 
        inline bool operator ==(const TensorFormat& other) const noexcept
        {
            return !(*this != other);
        }
 
        inline bool operator <(const TensorFormat& other) const noexcept
        {
            return std::tie(elementType, layout) < std::tie(other.elementType, other.layout);
        }
    };
 
    // The Neural plugin ABI assumes a TensorFormat can fit in a single 32-bit register
    static_assert(sizeof(TensorFormat) == sizeof(std::uint32_t), "TensorFormat structure packing not as expected");
 
    struct TensorDimension
    {
        size_t n = 0; 
        size_t c = 0; 
        size_t h = 0; 
        size_t w = 0; 
 
        inline TensorDimension() = default;
 
        inline TensorDimension(size_t N, size_t C, size_t H, size_t W)
            : n{N}
            , c{C}
            , h{H}
            , w{W}
        {
        }
 
        ~TensorDimension() = default;
 
        inline TensorDimension(const TensorDimension& copyFrom)
            : n{copyFrom.n}
            , c{copyFrom.c}
            , h{copyFrom.h}
            , w{copyFrom.w}
        {
        }
 
        inline TensorDimension& operator =(const TensorDimension& copyFrom)
        {
            n = copyFrom.n;
            c = copyFrom.c;
            h = copyFrom.h;
            w = copyFrom.w;
            return *this;
        }
 
        inline bool operator ==(const TensorDimension& other) const
        {
            return (n == other.n) && (c == other.c) && (h == other.h) && (w == other.w);
        }
 
        inline bool operator !=(const TensorDimension& other) const
        {
            return !(*this == other);
        }
 
        inline std::size_t elementCount() const
        {
            return n * c * h *w;
        }
    };
 
    // The Neural plugin ABI assumes a TensorDimension remains a POD type.
    static_assert(std::is_standard_layout<TensorDimension>::value, "TensorDimension must be standard layout");
 
    class Float16
    {
    public:
        std::uint16_t data = 0u;
 
        Float16() = default;
 
        Float16(const Float16& copyFrom);
 
        explicit Float16(float value);
 
        inline Float16& operator=(double value)
        {
            *this = Float16(static_cast<float>(value));
            return *this;
        }
 
        inline Float16& operator =(const Float16& copyFrom)
        {
            data = copyFrom.data;
            return *this;
        }
 
        operator float() const;
    };
 
    enum class NetworkBackendId : std::uint32_t
    {
        Invalid = 0,
 
        TestOnly = 1,          
        Cpu = 2,               
        Cuda = 3,              
 
        CustomBase = 0x4000u,  
    };
 
    enum class ActivationFunctionId : std::uint32_t
    {
        None = 0,              
        ReLU = 1,              
        LeakyReLU = 2,         
        LeakySigmoid = 3,      
        LeakyTanh = 4,         
        Tanh = 5,              
        Sigmoid = 6,           
        Softmax = 7,           
        Sine = 8,              
 
        CustomBase = 0x4000u,  
    };
 
    enum class NeuralResult : std::int32_t
    {
        // *If* we need them, additional success codes will go here (e.g., S_FALSE = -1)
        Success = 0,      
        Failure = 1,      
        Unsupported = 2,  
        // *If* we need them, additional failure codes will go here (e.g., E_POINTER = 3)
    };
 
    inline constexpr bool succeeded(NeuralResult result) noexcept
    {
        return result <= NeuralResult::Success;
    }
    inline constexpr bool failed(NeuralResult result) noexcept
    {
        return result >= NeuralResult::Failure;
    }
 
    enum class ImageSpace : std::uint32_t
    {
        Invalid = 0,          
        RgbNormalized = 1,    
        RgbCentered = 2,      
 
        CustomBase = 0x4000u, 
    };
 
    class IRefObject
    {
    public:
        using RefCount = std::uint32_t;
 
        using TypeId = std::uint64_t;
 
        static const TypeId typeID = 0x14ecc3f9de638e1dul;
 
        virtual RefCount addRef() const noexcept = 0;
 
        virtual RefCount release() const noexcept = 0;
 
        virtual void* queryInterface(TypeId interface) noexcept = 0;
 
        virtual const void* queryInterface(TypeId interface) const noexcept = 0;
 
    protected:
        virtual ~IRefObject() = default;
    };
 
    template<typename TInterface>
    struct InterfaceOf
    {
        static constexpr IRefObject::TypeId value = TInterface::typeID;
    };
 
    class ILogger : public IRefObject
    {
    public:
        static const IRefObject::TypeId typeID = 0xd74335d06aa1ba61ul;
 
        using VerbosityLevel = std::int32_t;
 
        virtual VerbosityLevel verbosity() const noexcept = 0;
 
        virtual NeuralResult log(VerbosityLevel verbosity, const char* format, ...) noexcept = 0;
 
        virtual NeuralResult logWarning(VerbosityLevel verbosity, const char* format, ...) noexcept = 0;
 
        virtual NeuralResult logError(VerbosityLevel verbosity, const char* format, ...) noexcept = 0;
    };
 
    class IApiVersionQuery : public IRefObject
    {
    public:
        static const IRefObject::TypeId typeID = 0x310ca743db44232dul;
 
        virtual std::uint32_t apiVersion() const noexcept = 0;
    };
 
    class IWeightsData : public IRefObject
    {
    public:
        static const IRefObject::TypeId typeID = 0xba912359795313f3ul;
 
        virtual NetworkBackendId backendId() const noexcept = 0;
 
        virtual TensorFormat tensorFormat() const noexcept = 0;
 
        virtual TensorDimension dimension() const noexcept = 0;
 
        virtual bool memManagedExternally() const noexcept = 0;
 
        virtual const void* data() const noexcept = 0;
    };
 
    class IWeightsLoader : public IRefObject
    {
    public:
        static const IRefObject::TypeId typeID = 0x5bac8f6ca68c52b6ul;
 
        virtual NeuralResult getWeightsForLayer(IWeightsData** ppWeightsDataOut, const INetworkRuntime* pNetwork, const ILayer* pLayer, const char* pName) const noexcept = 0;
    };
 
    class IRuntimeOptionsHost : public IRefObject
    {
    public:
        static const IRefObject::TypeId typeID = 0x9874b8d21b0c9697ul;
 
        virtual NeuralResult optionsRefreshed(const ILayer* pLayer) noexcept = 0;
    };
 
    class ILibraryContext : public IRefObject
    {
    public:
        static const IRefObject::TypeId typeID = 0x1ec1c40bfc1e45a4ul;
 
        using LibraryId = std::uint64_t;
 
        virtual LibraryId libraryId() const noexcept = 0;
 
        virtual NeuralResult synchronize(INetworkBackend* pBackend) noexcept = 0;
 
        virtual NeuralResult bindCurrentThread(INetworkBackend* pBackend) noexcept = 0;
    };
 
    class IBackendDeviceIdentifier : public IRefObject
    {
    public:
        static const IRefObject::TypeId typeID = 0xf78683bf5a3d24a9ul;
 
        virtual NeuralResult getDeviceIdentifiers(std::uint64_t* pUuidLow, std::uint64_t* pUuidHigh) const noexcept = 0;
 
        virtual const char* getDeviceName() const noexcept = 0;
    };
 
    class MemoryHandle__type;
 
    using MemoryHandle = MemoryHandle__type*;
 
    enum class MemorySemantic : std::uint32_t
    {
        Unspecified = 0u,      
        Tensor      = 1u,      
        Weights     = 2u,      
        Ephemeral   = 3u,      
 
        CustomBase  = 0x4000u  
    };
 
    class INetworkBackend : public IRefObject
    {
    public:
        static const IRefObject::TypeId typeID = 0xacd7828da90108ddul;
 
 
        enum class OptimizationCapability : std::uint64_t
        {
            SkipConcatenation = 0xdd13d58fbabb2f5bul,
 
            FuseBatchNormAndConvolution = 0xeaffe6d9a4acfdc9ul,
        };
 
        virtual bool supportsOptimization(OptimizationCapability optimization) const noexcept = 0;
 
 
 
        virtual NeuralResult initializeFromDeviceOrdinal(std::uint32_t deviceOrdinal) noexcept = 0;
 
        virtual NeuralResult initializeFromDeviceIdentifier(const IBackendDeviceIdentifier* pDeviceIdentifier) noexcept = 0;
 
        virtual const IBackendDeviceIdentifier* deviceIdentifier() const noexcept = 0;
 
 
        virtual NetworkBackendId id() const noexcept = 0;
 
        virtual NeuralResult synchronize() noexcept = 0;
 
        virtual NeuralResult bindCurrentThread() noexcept = 0;
 
        virtual NeuralResult transformTensor(
            void* pDeviceDestination,
            TensorFormat destinationFormat,
            TensorDimension destinationSize,
            const void* pDeviceSource,
            TensorFormat sourceFormat,
            TensorDimension sourceSize) noexcept = 0;
 
 
        virtual NeuralResult setDeviceMemory(void* pDeviceDestination, std::uint8_t value, std::size_t byteCount) noexcept = 0;
 
        virtual NeuralResult copyMemoryD2D(void* pDeviceDestination, const void* pDeviceSource, std::size_t byteCount) noexcept = 0;
 
        virtual NeuralResult copyMemoryH2D(void* pDeviceDestination, const void* pHostSource, std::size_t byteCount) noexcept = 0;
 
        virtual NeuralResult copyMemoryD2H(void* pHostDestination, const void* pDeviceSource, std::size_t byteCount) noexcept = 0;
 
 
 
        virtual NeuralResult registerLibraryContext(ILibraryContext* pLibraryContext) noexcept = 0;
 
        virtual ILibraryContext* getLibraryContext(ILibraryContext::LibraryId libraryId) noexcept = 0;
 
        virtual const ILibraryContext* getLibraryContext(ILibraryContext::LibraryId libraryId) const noexcept = 0;
 
 
 
        virtual NeuralResult allocateMemoryBlock(MemoryHandle* pHandle, size_t byteCount) noexcept = 0;
 
        virtual NeuralResult freeMemoryBlock(MemoryHandle handle) noexcept = 0;
 
        virtual void* getAddressForMemoryBlock(MemoryHandle handle) noexcept = 0;
 
        virtual size_t getSizeForMemoryBlock(MemoryHandle handle) noexcept = 0;
 
        virtual NeuralResult lockMemoryBlock(MemoryHandle handle) noexcept = 0;
 
        virtual NeuralResult unlockMemoryBlock(MemoryHandle handle) noexcept = 0;
 
        virtual MemoryHandle updateTensor(
            const ILayer* pLayer,
            INetworkRuntime* pNetwork,
            TensorFormat format,
            MemoryHandle hOriginal,
            TensorDimension stepping,
            TensorDimension internalDimensions) noexcept = 0;
 
 
 
        virtual NeuralResult clearLoadedWeights() noexcept = 0;
 
        virtual NeuralResult uploadWeights(
            const void** ppUploadedWeightsOut,
            const ILayer* pLayer,
            const IWeightsLoader* pOriginWeightLoader,
            const char* pName,
            const void* pWeightsData,
            std::size_t weightsDataSize,
            TensorDimension weightsDim,
            TensorFormat format,
            bool memManagedExternally) noexcept = 0;
 
        virtual const void* getAddressForWeightsData(const ILayer* pLayer, const IWeightsLoader* pOriginWeightLoader, const char* pName, TensorFormat format) const noexcept = 0;
 
        virtual NeuralResult getDimensionsForWeightsData(TensorDimension* pDimensionOut, const ILayer* pLayer, const IWeightsLoader* pOriginWeightLoader, const char* pName, TensorFormat format) const noexcept = 0;
 
        virtual NeuralResult getWeightsNamesForLayer(IStringList** ppListOut, const ILayer* pLayer, const IWeightsLoader* pOriginWeightLoader) const noexcept = 0;
 
 
        virtual NeuralResult saveImage(const ILayer* pLayer, const INetworkRuntime* pNetwork, IImage* pImage, ImageSpace imageSpace, size_t channels) noexcept = 0;
    };
 
    struct MemoryTrackingData
    {
        std::size_t structSize;
 
        std::size_t peakCommittedMemory;
 
        std::size_t peakRequestedMemory;
 
        std::size_t persistingCommittedMemory;
 
        std::size_t persistingRequestedMemory;
    };
 
    class INetworkBackend2 : public INetworkBackend
    {
    public:
        static const IRefObject::TypeId typeID = 0x02793dfd8bfde737ul;
 
        using INetworkBackend::allocateMemoryBlock;
 
 
        virtual NeuralResult allocateMemoryBlock(MemoryHandle* pHandle, size_t byteCount, const char* pTrackingKey) noexcept = 0;
 
        virtual const MemoryTrackingData* getMemoryTrackingData(const char* pTrackingKey, const char* pTrackingSubkey) const noexcept = 0;
 
        virtual NeuralResult getMemoryTrackingKeys(IStringList** ppKeysOut) noexcept = 0;
 
        virtual NeuralResult getMemoryTrackingSubkeys(const char* pTrackingKey, IStringList** ppKeysOut) noexcept = 0;
 
        virtual NeuralResult setMemoryTrackingKey(const char* pTrackingKey, const char* pTrackingSubkey) noexcept = 0;
 
 
    };
 
    class ILayerList : public IRefObject
    {
    public:
        static const IRefObject::TypeId typeID = 0x28d94b933a3b0dabul;
 
        virtual size_t layerCount() const noexcept = 0;
 
        virtual ILayer* getLayerByIndex(size_t layerIndex) const noexcept = 0;
    };
 
    class IStringList : public IRefObject
    {
    public:
        static const IRefObject::TypeId typeID = 0x5952141d72c5cda0ul;
 
        virtual size_t stringCount() const noexcept = 0;
 
        virtual const char* getStringByIndex(size_t stringIndex) const noexcept = 0;
 
        virtual size_t getStringSizeByIndex(size_t stringIndex) const noexcept = 0;
    };
 
    class INetworkDebugger; // forward reference
 
    class INetworkDebuggerList : public IRefObject
    {
    public:
        static const IRefObject::TypeId typeID = 0xde9c8f7c71a9dcbaul;
 
        virtual size_t debuggerCount() const noexcept = 0;
 
        virtual INetworkDebugger* getNetworkDebuggerByIndex(size_t index) const noexcept = 0;
    };
 
    class INetworkRuntime : public IRefObject
    {
    public:
        static const IRefObject::TypeId typeID = 0x53191c073f990992ul;
 
        virtual const char* networkName() const noexcept = 0;
 
        virtual INetworkBackend* getBackend(NetworkBackendId backendId) noexcept = 0;
 
        virtual const INetworkBackend* getBackend(NetworkBackendId backendId) const noexcept = 0;
 
        virtual NeuralResult defaultForwardActivation(ILayer* pLayer) const noexcept = 0;
 
        virtual IWeightsLoader* weightsLoader() const noexcept = 0;
 
        virtual NetworkBackendId defaultBackendId() const noexcept = 0;
 
        virtual TensorFormat defaultTensorFormat() const noexcept = 0;
 
        virtual NeuralResult reshapeLater(ILayer* pLayer) noexcept = 0;
 
 
        virtual size_t layerCount() const noexcept = 0;
 
        virtual ILayer* getLayerByName(const char* pLayerName) const noexcept = 0;
 
        virtual NeuralResult getAllLayers(ILayerList** ppListOut) const noexcept = 0;
 
        virtual NeuralResult getInputLayers(ILayerList** ppListOut) const noexcept = 0;
 
        virtual NeuralResult getOutputLayers(ILayerList** ppListOut) const noexcept = 0;
 
        virtual NeuralResult getDependentLayers(ILayerList** ppListOut, const ILayer* pLayer) const noexcept = 0;
 
        virtual NeuralResult getAcceptorLayers(ILayerList** ppListOut, const ILayer* pLayer) const noexcept = 0;
 
        virtual NeuralResult getInfluenceLayers(ILayerList** ppListOut, const ILayer* pLayer) const noexcept = 0;
 
 
        virtual NeuralResult setAffectedForward(ILayer* pLayer) noexcept = 0;
 
        virtual void* getTensor(const ILayer* pDataLayer, const ILayer* pRequestingLayer, TensorFormat format) noexcept = 0;
 
        virtual void* getInternalTensor(const ILayer* pLayer, NetworkBackendId backendId) noexcept = 0;
 
        virtual NeuralResult mapLayerAsWeightsData(const ILayer* pDataLayer, const ILayer* pWeightsLayer, const char* pWeightsName) noexcept = 0;
 
        virtual const void* getWeightsForLayer(const ILayer* pLayer, const char* pWeightsName, NetworkBackendId backendId, TensorFormat format) noexcept = 0;
 
        virtual NeuralResult getWeightsDimensionForLayer(
            TensorDimension* pDimensionsOut,
            const ILayer* pLayer,
            const char* pWeightsName,
            NetworkBackendId backendId,
            TensorFormat format) noexcept = 0;
 
        virtual TensorDimension getLayerInternalDimensions(const ILayer* pLayer) const noexcept = 0;
    };
 
    enum class ParamType : std::uint16_t
    {
        String          = 0,
        SizeT           = 1,
        Float           = 2,
        Enumeration     = 3,
        Dimension       = 4,
        Bool            = 5,
        MaxParam,                   
        CustomBase      = 0x4000u,  
    };
 
    struct BaseParamTypeDesc
    {
        std::size_t structSize;
 
        ParamType paramType;
    };
 
    struct ParamDependencyDesc
    {
        const char* pParamName;
 
        const char* pParamValue;
    };
 
    struct DimensionParamTypeDesc
    {
        BaseParamTypeDesc baseDesc;
 
        std::size_t maxDimensions;
 
        std::size_t minDimensions;
 
        std::size_t paramDependenciesCount;
 
        const ParamDependencyDesc* pParamDependencies;
    };
 
    struct EnumParamTypeDesc
    {
        BaseParamTypeDesc baseDesc;
 
        std::size_t optionCount;
 
        const char* const* pOptions;
 
        std::size_t paramDependenciesCount;
 
        const ParamDependencyDesc* pParamDependencies;
    };
 
    struct StringParamTypeDesc
    {
        BaseParamTypeDesc baseDesc;
 
        bool supportsMultilineTextbox;
 
        std::size_t paramDependenciesCount;
 
        const ParamDependencyDesc* pParamDependencies;
    };
 
    struct ParamDesc
    {
        std::size_t structSize;
 
        const char* pName;
 
        const char* pDefault;
 
        ParamType paramType;
 
        const char* pDocumentation;
 
        const BaseParamTypeDesc* pParamTypeDetails;
    };
 
    namespace common_categories
    {
        const char* const General               = "General"; 
        const char* const InputOutput           = "Input/Output"; 
        const char* const Training              = "Training"; 
        const char* const FormatConversion      = "Format Conversion"; 
        const char* const Shape                 = "Shape"; 
        const char* const Upsampling            = "Upsampling"; 
        const char* const Fused                 = "Fused"; 
        const char* const Examples              = "Examples"; 
        const char* const DataImageProcessing   = "Data/Image Processing"; 
        const char* const DomainSpecific        = "Domain Specific"; 
        const char* const DevelopmentAids       = "Development Aids"; 
        const char* const Analysis              = "Analysis"; 
        const char* const DefaultHidden         = "Hidden"; 
        const char* const NoActivation          = "No Activation"; 
    } // namespace nvneural::common_categories
 
    enum class LayerInputType : std::uint16_t
    {
        Primary             = 0,        
        PrimaryInfinite     = 1,        
        Secondary           = 2,        
        CustomBase          = 0x4000u   
    };
 
    struct LayerInputDesc
    {
        std::size_t structSize;
 
        const char* pName;
 
        const char* pDocumentation;
 
        LayerInputType inputType;
    };
 
 
    struct LayerDesc
    {
        std::size_t structSize;
 
        const char* pObjectClass;
 
        const char* pSerializedName;
 
        const char* pDocumentation;
 
        const char* pDisplayName;
 
        std::size_t numCategories;
 
        const char* const* ppCategories;
 
        NetworkBackendId backend;
 
        TensorFormat tensorFormat;
 
        std::size_t numInputs;
 
        const LayerInputDesc* pInputs;
 
        bool generatesOutput;
 
        std::size_t numParameters;
 
        const ParamDesc* pParameters;
    };
 
    struct ActivationDesc
    {
        std::size_t structSize;
 
        const char* pObjectClass;
 
        const char* pSerializedName;
 
        const char* pDocumentation;
 
        const char* pDisplayName;
 
        ActivationFunctionId activationFunction;
 
        NetworkBackendId backend;
 
        TensorFormat tensorFormat;
 
        std::size_t numParameters;
 
        const ParamDesc* pParameters;
    };
 
    enum class CompilationLevel : std::uint16_t
    {
        CompiledBinary = 0,     
        JitIntermediate = 1,    
        JitSource = 2,          
    };
 
    struct PrototypeDesc
    {
        std::size_t structSize;
 
        const char* pObjectClass;
 
        const char* pSerializedName;
 
        const char* pDisplayName;
 
        NetworkBackendId backend;
 
        TensorFormat tensorFormat;
 
        CompilationLevel compilationLevel;
    };
 
    typedef bool (*PrototypeRuntimeValidatorFunction)(const INetwork* pNetwork);
 
    struct FusingRule
    {
        std::uint32_t syntaxVersion;
 
        const char* pFusingRule;
    };
 
    class IClassRegistry : public IRefObject
    {
    public:
        static const IRefObject::TypeId typeID =  0x261ae312ee3c4979ul;
 
        virtual NeuralResult importPlugin(IPlugin* pPlugin) = 0;
 
        virtual NeuralResult importPluginLoader(IPluginLoader* pPluginLoader) = 0;
 
        virtual std::size_t exportedActivationsCount() const noexcept = 0;
 
        virtual const ActivationDesc* exportedActivationByIndex(std::size_t index) const noexcept = 0;
 
        virtual std::size_t exportedLayersCount() const noexcept = 0;
 
        virtual const LayerDesc* exportedLayerByIndex(std::size_t index) const noexcept = 0;
 
        virtual std::size_t exportedFusingRulesCount() const noexcept =  0;
 
        virtual const FusingRule* exportedFusingRuleByIndex(std::size_t index) const noexcept = 0;
 
        virtual std::size_t exportedPrototypesCount() const noexcept = 0;
 
        virtual const PrototypeDesc* exportedPrototypeByIndex(std::size_t index) const noexcept = 0;
 
        virtual PrototypeRuntimeValidatorFunction exportedPrototypeRuntimeValidatorByIndex(std::size_t index) const noexcept = 0;
 
        virtual NeuralResult createObject(IRefObject** ppOut, const char* pObjectClass) const noexcept = 0;
 
        virtual bool isPrototypeRuntimeCompatible(const char* pPrototypeObjectClass, const INetwork* pNetwork) const = 0;
    };
 
    class IParameterNode : public IRefObject
    {
    public:
        static const IRefObject::TypeId typeID = 0x4f0ffb1d41d49fcul;
 
 
        virtual NeuralResult getInteger(const char* pParameterName, std::int32_t* pIntOut) const noexcept = 0;
 
        virtual NeuralResult getSize(const char* pParameterName, std::size_t* pSizeOut) const noexcept = 0;
 
        virtual NeuralResult getFloat(const char* pParameterName, float* pFloatOut) const noexcept = 0;
 
        virtual NeuralResult getString(const char* pParameterName, const char** pStringOut) const noexcept = 0;
 
        virtual NeuralResult getDimension(const char* pParameterName, TensorDimension* pDimOut) const noexcept = 0;
 
 
 
        virtual NeuralResult setInteger(const char* pParameterName, std::int32_t value) noexcept = 0;
 
        virtual NeuralResult setSize(const char* pParameterName, std::size_t value) noexcept = 0;
 
        virtual NeuralResult setFloat(const char* pParameterName, float value) noexcept = 0;
 
        virtual NeuralResult setString(const char* pParameterName, const char* pString) noexcept = 0;
 
        virtual NeuralResult setDimension(const char* pParameterName, TensorDimension value) noexcept = 0;
 
    };
 
    class IImage : public IRefObject
    {
    public:
        static const IRefObject::TypeId typeID = 0x2a21f61fbfee3221ul;
 
        virtual NeuralResult resize(std::size_t height, std::size_t width, std::size_t channels) noexcept = 0;
 
        virtual std::size_t height() const noexcept = 0;
 
        virtual std::size_t width() const noexcept = 0;
 
        virtual std::size_t channels() const noexcept = 0;
 
        virtual std::size_t elements() const noexcept = 0;
 
        virtual std::uint8_t* data() noexcept = 0;
 
        virtual const std::uint8_t* data() const noexcept = 0;
    };
 
    class IActivationFunction : public IRefObject
    {
    public:
        static const IRefObject::TypeId typeID = 0x66e36120ed8745d8ul;
 
        virtual NeuralResult setNetworkRuntime(INetworkRuntime* pNetwork) noexcept = 0;
 
        virtual NeuralResult invoke(ILayer* pLayer) noexcept = 0;
 
        virtual const char* serializedType() const noexcept = 0;
    };
 
} // namespace nvneural
 
#endif // NVNEURAL_CORETYPES_H