SimpleNode.hpp

Go to the documentation of this file.

//
// Notice
// ALL NVIDIA DESIGN SPECIFICATIONS AND CODE ("MATERIALS") ARE PROVIDED "AS IS" NVIDIA MAKES
// NO REPRESENTATIONS, WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
// THE MATERIALS, AND EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTIES OF NONINFRINGEMENT,
// MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
//
// NVIDIA CORPORATION & AFFILIATES assumes no responsibility for the consequences of use of such
// information or for any infringement of patents or other rights of third parties that may
// result from its use. No license is granted by implication or otherwise under any patent
// or patent rights of NVIDIA CORPORATION & AFFILIATES. No third party distribution is allowed unless
// expressly authorized by NVIDIA. Details are subject to change without notice.
// This code supersedes and replaces all information previously supplied.
// NVIDIA CORPORATION & AFFILIATES products are not authorized for use as critical
// components in life support devices or systems without express written approval of
// NVIDIA CORPORATION & AFFILIATES.
//
// SPDX-FileCopyrightText: Copyright (c) 2019-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
// SPDX-License-Identifier: LicenseRef-NvidiaProprietary
//
// NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
// property and proprietary rights in and to this material, related
// documentation and any modifications thereto. Any use, reproduction,
// disclosure or distribution of this material and related documentation
// without an express license agreement from NVIDIA CORPORATION or
// its affiliates is strictly prohibited.
//

#ifndef DW_FRAMEWORK_SIMPLENODE_HPP_
#define DW_FRAMEWORK_SIMPLENODE_HPP_

#include <dw/core/base/Types.h>
#include <dwcgf/Exception.hpp>
#include <dwcgf/Types.hpp>
#include <dwcgf/channel/Channel.hpp>
#include <dwcgf/pass/Pass.hpp>
#include <dwcgf/node/Node.hpp>
#include <dwcgf/pass/PassDescriptor.hpp>
#include <dwcgf/port/ManagedPort.hpp>
#include <dwcgf/port/PortCollectionDescriptor.hpp>
#include <dwcgf/port/PortDescriptor.hpp>
#include <dwcgf/port/RegisteredPort.hpp>

#include <dw/core/container/VectorFixed.hpp>
#include <dw/core/container/BaseString.hpp>

#include <functional>
#include <map>

namespace dw
{
namespace framework
{

class SimpleProcessNode;
class SimpleSensorNode;

struct NodeAllocationParams
{
    size_t maxInputPortCount  = Node::MAX_PORT_COUNT;
    size_t maxOutputPortCount = Node::MAX_PORT_COUNT;
    size_t maxPassCount       = Node::MAX_PASS_COUNT;
};

template <typename NodeT>
NodeAllocationParams createAllocationParams()
{
    NodeAllocationParams params;
    params.maxInputPortCount  = portSize<NodeT, PortDirection::INPUT>();
    params.maxOutputPortCount = portSize<NodeT, PortDirection::OUTPUT>();
    params.maxPassCount       = passSize<NodeT>();
    return params;
}

class SimpleNode : public Node
{
public:
    static constexpr const char* PASS_SETUP_NAME    = "SETUP";
    static constexpr const char* PASS_TEARDOWN_NAME = "TEARDOWN";

    SimpleNode();
    SimpleNode(NodeAllocationParams params);
    virtual ~SimpleNode();

    dwStatus reset() override
    {
        throw Exception(DW_NOT_IMPLEMENTED, "Not implemented");
    }


    dwStatus setInputChannel(ChannelObject* channel, uint8_t portID) override;

    dwStatus setInputChannel(ChannelObject*, uint8_t, dwSerializationType) override
    {
        throw Exception(DW_NOT_IMPLEMENTED, "Not implemented");
    }


    dwStatus setOutputChannel(ChannelObject* channel, uint8_t portID) override;

    dwStatus validate() override
    {
        throw Exception(DW_NOT_IMPLEMENTED, "Not implemented");
    }


    dwStatus validate(const char* direction, const PortCollectionDescriptor& collection, const dw::core::HeapHashMap<size_t, std::shared_ptr<PortBase>>& ports, size_t indexOffset = 0);

    dwStatus run() override;
    size_t getPassCount() const noexcept override;
    dwStatus runPassByID(uint8_t passID) override;
    dwStatus runPass(size_t passIndex) override;
    dwStatus getPasses(VectorFixed<Pass*>& passList) override;
    dwStatus getPasses(VectorFixed<Pass*>& passList, dwProcessorType processorType, dwProcessType processType) override;

    dwStatus setName(const char* name) final;
    dwStatus getName(const char** name) override;

    dwStatus getHealthSignals(dwGraphHealthSignalArray*& healthSignals) override;

    template <typename Func, typename PortList>
    void iteratePorts(PortList& portList, Func func)
    {
        for (auto elem : portList)
        {
            func(elem);
        }
    }

    template <typename Func>
    void iterateManagedInputPorts(Func func)
    {
        iteratePorts(m_inputPorts, [&func, this](decltype(m_inputPorts)::TElement& elem) {
            if (auto managedPort = dynamic_cast<ManagedPortInputBase*>(elem.second.get()))
            {
                func(*managedPort);
            }
            else
            {
                const char* nodeName = nullptr;
                this->getName(&nodeName);
                throw Exception(DW_BAD_CAST, "SimpleNode: ports are wrong class, node ", nodeName);
            }
        });
    }

    template <typename Func>
    void iterateManagedOutputPorts(Func func)
    {
        iteratePorts(m_outputPorts, [&func, this](decltype(m_outputPorts)::TElement& elem) {
            if (auto managedPort = dynamic_cast<ManagedPortOutputBase*>(elem.second.get()))
            {
                func(*managedPort);
            }
            else
            {
                const char* nodeName = nullptr;
                this->getName(&nodeName);
                throw Exception(DW_BAD_CAST, "SimpleNode: ports are wrong class node ", nodeName);
            }
        });
    }

    template <typename ModuleHandle_t>
    dwStatus setModuleHandle(ModuleHandle_t handle, dwContextHandle_t context)
    {
        dwModuleHandle_t moduleHandle;

        if (DW_NULL_HANDLE == handle)
        {
            return DW_INVALID_ARGUMENT;
        }

        dwStatus ret = getModuleHandle(&moduleHandle, handle, context);
        if (DW_SUCCESS != ret)
        {
            return ret;
        }

        return setObjectHandle(moduleHandle);
    }

    virtual dwStatus setObjectHandle(dwModuleHandle_t handle);

protected:
    dwStatus getModuleHandle(dwModuleHandle_t* moduleHandle, void* handle, dwContextHandle_t context);

    virtual std::unique_ptr<Pass> createSetupPass()
    {
        throw Exception(DW_NOT_IMPLEMENTED, "Not implemented");
    }

    virtual std::unique_ptr<Pass> createTeardownPass()
    {
        throw Exception(DW_NOT_IMPLEMENTED, "Not implemented");
    }

    template <typename PassFunctionT, typename... Args>
    std::unique_ptr<PassImpl<PassFunctionT>> make_pass(PassFunctionT func, Args&&... args)
    {
        return make_pass_with_node(this, func, std::forward<Args>(args)...);
    }


    template <
        typename NodeT, size_t PassIndex, typename PassFunctionT>
    void registerPass(PassFunctionT func, NvMediaDla* dlaEngine = nullptr)
    {
        registerPassWithNode<NodeT, PassIndex>(this, func, dlaEngine);
    }

public:

    template <typename PassFunctionT, typename... Args>
    std::unique_ptr<PassImpl<PassFunctionT>> make_pass_with_node(Node* node, PassFunctionT func, Args&&... args)
    {
        return std::make_unique<PassImpl<PassFunctionT>>(node, func, std::forward<Args>(args)...);
    }


    template <
        typename NodeT, size_t PassIndex, typename PassFunctionT>
    void registerPassWithNode(Node* node, PassFunctionT func, NvMediaDla* dlaEngine = nullptr)
    {
        if (!isValidPass<NodeT>(PassIndex))
        {
            throw Exception(DW_INVALID_ARGUMENT, "registerPassWithNode called with an invalid pass id: ", PassIndex);
        }
        if (m_passList.size() == 0 || m_passList.size() - 1 < PassIndex)
        {
            m_passList.resize(PassIndex + 1);
            m_passOwnershipList.resize(PassIndex + 1);
        }
        if (m_passList[PassIndex] != nullptr)
        {
            throw Exception(DW_INVALID_ARGUMENT, "registerPassWithNode called with a pass id which has been added before: ", PassIndex);
        }
        dwProcessorType processorType = passProcessorType<NodeT, PassIndex>();
        dwProcessType processType     = determineProcessType(processorType);
        if (dlaEngine == nullptr)
        {
            m_passList[PassIndex] = std::make_unique<PassImpl<PassFunctionT>>(node, func, processorType, processType, -1, -1, -1);
        }
        else if (processorType == DW_PROCESSOR_TYPE_DLA_0)
        {
            m_passList[PassIndex] = std::make_unique<PassImpl<PassFunctionT>>(node, func, processorType, processType, -1, -1, -1, dlaEngine);
        }
        else
        {
            throw Exception(DW_INVALID_ARGUMENT, "registerPassWithNode called with a pass which has dlaEngine but not a DLA pass: ", PassIndex);
        }
        m_passOwnershipList[PassIndex] = true;
    }

    void addPass(std::function<std::unique_ptr<Pass>(void)> createSetup, std::function<std::unique_ptr<Pass>(void)> createTeardown, Pass* pass);

    /*
    * @brief Clears the current Health Signals from the Health Signal Array
    * @param None
    * @return DW_SUCCESS
    */
    dwStatus clearHealthSignals();

    /*
    * @brief Adds the provided Health Signal to the Health Signal Array. If the array is full, the new signal will not be added.
    * @param signal The Health Signal to add
    * @return DW_SUCCESS, or DW_BUFFER_FULL if the array is currently full.
    */
    dwStatus addHealthSignal(const dwGraphHealthSignal& signal);

private:
    inline dwProcessType determineProcessType(dwProcessorType processorType)
    {
        if (processorType == DW_PROCESSOR_TYPE_GPU ||
            processorType == DW_PROCESSOR_TYPE_DLA_0)
        {
            return DW_PROCESS_TYPE_ASYNC;
        }
        return DW_PROCESS_TYPE_SYNC;
    }

    VectorFixed<std::unique_ptr<Pass>> m_passList;
    // tracking ownership is only necessary until addPass(..., Pass* pass) is removed
    VectorFixed<bool> m_passOwnershipList;
    FixedString<MAX_NAME_LEN> m_name{};
    bool m_setupTeardownCreated = false;

    /* An array of health signals generated by this node. By default this will contain a single signal with fields set to UNKNOWN.
    * User should overwrite this value with their own health signals. These signals will be collected whenever a pass returns
    * a non-successful return code.
    */
    dwGraphHealthSignalArray m_healthSignals{};

    dwModuleHandle_t m_object{};
    uint32_t m_iterationCount{};

public:
    template <typename TPort, typename... Args>
    std::unique_ptr<TPort> make_port(Args&&... args)
    {
        auto port = std::make_unique<TPort>(std::forward<Args>(args)...);
        port->setSyncRetriever(std::bind(&SimpleNode::getIterationCount, this));
        return port;
    }


    template <typename NodeT, size_t PortIndex, typename... Args>
    void initInputPort(Args&&... args)
    {
        using DataType = decltype(portType<NodeT, PortDirection::INPUT, PortIndex>());
        auto port      = std::make_shared<ManagedPortInput<DataType>>(std::forward<Args>(args)...);
        if (m_inputPorts.find(PortIndex) != m_inputPorts.end())
        {
            throw Exception(DW_INVALID_ARGUMENT, "Input port with the following id registered multiple times: ", PortIndex);
        }
        m_inputPorts[PortIndex] = port;
    }


    template <typename NodeT, size_t PortIndex, typename... Args>
    void initInputArrayPort(Args&&... args)
    {
        using DataType                    = decltype(portType<NodeT, PortDirection::INPUT, PortIndex>());
        constexpr size_t descriptor_index = descriptorIndex<NodeT, PortDirection::INPUT, PortIndex>();
        constexpr size_t arraySize        = descriptorPortSize<NodeT, PortDirection::INPUT, descriptor_index>();
        for (size_t i = 0; i < arraySize; ++i)
        {
            auto port = std::make_shared<ManagedPortInput<DataType>>(std::forward<Args>(args)...);
            if (m_inputPorts.find(PortIndex + i) != m_inputPorts.end())
            {
                throw Exception(DW_INVALID_ARGUMENT, "Input port with the following id registered multiple times: ", PortIndex + i);
            }
            m_inputPorts[PortIndex + i] = port;
        }
    }


    template <typename NodeT, size_t PortIndex, typename... Args>
    void initOutputPort(Args&&... args)
    {
        using DataType = decltype(portType<NodeT, PortDirection::OUTPUT, PortIndex>());
        auto port      = std::make_shared<ManagedPortOutput<DataType>>(std::forward<Args>(args)...);
        if (m_outputPorts.find(PortIndex) != m_outputPorts.end())
        {
            throw Exception(DW_INVALID_ARGUMENT, "Output port with the following id registered multiple times: ", PortIndex);
        }
        m_outputPorts[PortIndex] = port;
    }


    template <typename NodeT, size_t PortIndex, typename... Args>
    void initOutputArrayPort(Args&&... args)
    {
        using DataType                    = decltype(portType<NodeT, PortDirection::OUTPUT, PortIndex>());
        constexpr size_t descriptor_index = descriptorIndex<NodeT, PortDirection::OUTPUT, PortIndex>();
        constexpr size_t arraySize        = descriptorPortSize<NodeT, PortDirection::OUTPUT, descriptor_index>();
        for (size_t i = 0; i < arraySize; ++i)
        {
            auto port = std::make_shared<ManagedPortOutput<DataType>>(std::forward<Args>(args)...);
            if (m_outputPorts.find(PortIndex + i) != m_outputPorts.end())
            {
                throw Exception(DW_INVALID_ARGUMENT, "Output port with the following id registered multiple times: ", PortIndex + i);
            }
            m_outputPorts[PortIndex + i] = port;
        }
    }

    template <typename NodeT, size_t PortIndex>
    ManagedPortInput<decltype(portType<NodeT, PortDirection::INPUT, PortIndex>())>& getInputPort()
    {
        constexpr bool isArray = descriptorPortArray<
            NodeT, PortDirection::INPUT, descriptorIndex<NodeT, PortDirection::INPUT, PortIndex>()>();
        static_assert(!isArray, "Input port is an array, must pass an array index");
        if (m_inputPorts.find(PortIndex) == m_inputPorts.end())
        {
            throw Exception(DW_INVALID_ARGUMENT, "Input port with the following id not registered: ", PortIndex);
        }
        using DataType    = decltype(portType<NodeT, PortDirection::INPUT, PortIndex>());
        using PointerType = ManagedPortInput<DataType>;
        using ReturnType  = std::shared_ptr<PointerType>;
        ReturnType port   = std::dynamic_pointer_cast<PointerType>(m_inputPorts[PortIndex]);
        if (!port)
        {
            throw Exception(DW_BAD_CAST, "Failed to cast the following input port to its declared type: ", PortIndex);
        }
        return *port;
    }

    template <typename NodeT, size_t PortIndex>
    ManagedPortInput<decltype(portType<NodeT, PortDirection::INPUT, PortIndex>())>& getInputPort(size_t arrayIndex)
    {
        constexpr bool isArray = descriptorPortArray<NodeT, PortDirection::INPUT, descriptorIndex<NodeT, PortDirection::INPUT, PortIndex>()>();
        static_assert(isArray, "Input port is not an array, must not pass an array index");
        constexpr size_t arraySize = descriptorPortSize<NodeT, PortDirection::INPUT, descriptorIndex<NodeT, PortDirection::INPUT, PortIndex>()>();
        if (arrayIndex >= arraySize)
        {
            throw Exception(DW_INVALID_ARGUMENT, "The array index is out of bound: ", arrayIndex);
        }
        if (m_inputPorts.find(PortIndex + arrayIndex) == m_inputPorts.end())
        {
            throw Exception(DW_INVALID_ARGUMENT, "Input port with the following id not registered: ", PortIndex + arrayIndex);
        }
        using DataType    = decltype(portType<NodeT, PortDirection::INPUT, PortIndex>());
        using PointerType = ManagedPortInput<DataType>;
        using ReturnType  = std::shared_ptr<PointerType>;
        ReturnType port   = std::dynamic_pointer_cast<PointerType>(m_inputPorts[PortIndex + arrayIndex]);
        if (!port)
        {
            throw Exception(DW_BAD_CAST, "Failed to cast the following input port to its declared type: ", PortIndex + arrayIndex);
        }
        return *port;
    }

    template <typename NodeT, size_t PortIndex>
    ManagedPortOutput<decltype(portType<NodeT, PortDirection::OUTPUT, PortIndex>())>& getOutputPort()
    {
        constexpr bool isArray = descriptorPortArray<
            NodeT, PortDirection::OUTPUT, descriptorIndex<NodeT, PortDirection::OUTPUT, PortIndex>()>();
        static_assert(!isArray, "Output port is an array, must pass an array index");
        if (m_outputPorts.find(PortIndex) == m_outputPorts.end())
        {
            throw Exception(DW_INVALID_ARGUMENT, "Output port with the following id not registered: ", PortIndex);
        }
        using DataType    = decltype(portType<NodeT, PortDirection::OUTPUT, PortIndex>());
        using PointerType = ManagedPortOutput<DataType>;
        using ReturnType  = std::shared_ptr<PointerType>;
        ReturnType port   = std::dynamic_pointer_cast<PointerType>(m_outputPorts[PortIndex]);
        if (!port)
        {
            throw Exception(DW_BAD_CAST, "Failed to cast the following output port to its declared type: ", PortIndex);
        }
        return *port;
    }

    template <typename NodeT, size_t PortIndex>
    ManagedPortOutput<decltype(portType<NodeT, PortDirection::OUTPUT, PortIndex>())>& getOutputPort(size_t arrayIndex)
    {
        constexpr bool isArray = descriptorPortArray<NodeT, PortDirection::OUTPUT, descriptorIndex<NodeT, PortDirection::OUTPUT, PortIndex>()>();
        static_assert(isArray, "Output port is not an array, must not pass an array index");
        constexpr size_t arraySize = descriptorPortSize<NodeT, PortDirection::OUTPUT, descriptorIndex<NodeT, PortDirection::OUTPUT, PortIndex>()>();
        if (arrayIndex >= arraySize)
        {
            throw Exception(DW_INVALID_ARGUMENT, "The array index is out of bound: ", arrayIndex);
        }
        if (m_outputPorts.find(PortIndex + arrayIndex) == m_outputPorts.end())
        {
            throw Exception(DW_INVALID_ARGUMENT, "Output port with the following id not registered: ", PortIndex + arrayIndex);
        }
        using DataType    = decltype(portType<NodeT, PortDirection::OUTPUT, PortIndex>());
        using PointerType = ManagedPortOutput<DataType>;
        using ReturnType  = std::shared_ptr<PointerType>;
        ReturnType port   = std::dynamic_pointer_cast<PointerType>(m_outputPorts[PortIndex + arrayIndex]);
        if (!port)
        {
            throw Exception(DW_BAD_CAST, "Failed to cast the following output port to its declared type: ", PortIndex + arrayIndex);
        }
        return *port;
    }


    dwStatus setup();


    dwStatus teardown();


    void resetPorts();

    dwStatus setIterationCount(uint32_t iterationCount) override;

    const dw::core::HeapHashMap<size_t, std::shared_ptr<PortBase>>& getRegisteredInputPorts() const
    {
        return m_inputPorts;
    }

    const dw::core::HeapHashMap<size_t, std::shared_ptr<PortBase>>& getRegisteredOutputPorts() const
    {
        return m_outputPorts;
    }

    uint32_t getIterationCount() const;

protected:
    dw::core::HeapHashMap<size_t, std::shared_ptr<PortBase>> m_inputPorts;
    dw::core::HeapHashMap<size_t, std::shared_ptr<PortBase>> m_outputPorts;
};

class SimpleSensorNode : public SensorNode
{
public:
    static constexpr char LOG_TAG[] = "SimpleSensorNode";

    SimpleSensorNode();
    SimpleSensorNode(NodeAllocationParams params);
    ~SimpleSensorNode() override = default;

    dwStatus run() override;
    size_t getPassCount() const noexcept override;
    dwStatus runPassByID(uint8_t passID) override;
    dwStatus runPass(size_t passIndex) override;
    dwStatus getPasses(VectorFixed<Pass*>& passList) override;
    dwStatus getPasses(VectorFixed<Pass*>& passList, dwProcessorType processorType, dwProcessType processType) override;

    dwStatus setName(const char* name) override;
    dwStatus getName(const char** name) override;

    dwStatus getHealthSignals(dwGraphHealthSignalArray*& healthSignals) override;

    dwStatus start() override
    {
        throw Exception(DW_NOT_IMPLEMENTED, "Not implemented");
    }

    dwStatus stop() override
    {
        throw Exception(DW_NOT_IMPLEMENTED, "Not implemented");
    }

    dwStatus reset() override
    {
        throw Exception(DW_NOT_IMPLEMENTED, "Not implemented");
    }

    dwStatus isVirtual(bool*) override
    {
        throw Exception(DW_NOT_IMPLEMENTED, "Not implemented");
    }

    dwStatus setDataEventReadCallback(DataEventReadCallback) override
    {
        throw Exception(DW_NOT_IMPLEMENTED, "Not implemented");
    }

    dwStatus setDataEventWriteCallback(DataEventWriteCallback) override
    {
        throw Exception(DW_NOT_IMPLEMENTED, "Not implemented");
    }

    dwStatus setInputChannel(ChannelObject* channel, uint8_t portID) override;

    dwStatus setInputChannel(ChannelObject* channel, uint8_t portID, dwSerializationType serialType) override;

    dwStatus setOutputChannel(ChannelObject* channel, uint8_t portID) override;

    dwStatus validate() override
    {
        throw Exception(DW_NOT_IMPLEMENTED, "Not implemented");
    }

    dwStatus validate(const char* direction, const PortCollectionDescriptor& collection, const dw::core::HeapHashMap<size_t, std::shared_ptr<PortBase>>& ports, size_t indexOffset = 0)
    {
        return m_simpleNode->validate(direction, collection, ports, indexOffset);
    }

protected:
    virtual std::unique_ptr<Pass> createSetupPass()
    {
        throw Exception(DW_NOT_IMPLEMENTED, "Not implemented");
    }

    virtual std::unique_ptr<Pass> createTeardownPass()
    {
        throw Exception(DW_NOT_IMPLEMENTED, "Not implemented");
    }

    dwStatus setup()
    {
        return m_simpleNode->setup();
    }

    dwStatus teardown()
    {
        return m_simpleNode->teardown();
    }

    void resetPorts()
    {
        m_simpleNode->resetPorts();
    }

    template <typename ModuleHandle_t>
    dwStatus setModuleHandle(ModuleHandle_t handle, dwContextHandle_t context)
    {
        return m_simpleNode->template setModuleHandle<>(handle, context);
    }

    dwStatus setObjectHandle(dwModuleHandle_t handle);

    template <typename PassFunctionT, typename... Args>
    std::unique_ptr<PassImpl<PassFunctionT>> make_pass(PassFunctionT func, Args&&... args)
    {
        return m_simpleNode->make_pass_with_node(this, func, std::forward<Args>(args)...);
    }

    template <
        typename NodeT, size_t PassIndex, typename PassFunctionT>
    void registerPass(PassFunctionT func, NvMediaDla* dlaEngine = nullptr)
    {
        m_simpleNode->registerPassWithNode<NodeT, PassIndex>(this, func, dlaEngine);
    }

    void addPass(Pass* pass);

    dwStatus clearHealthSignals();

    dwStatus addHealthSignal(const dwGraphHealthSignal& signal);

    std::atomic<bool> m_asyncResetFlag;

private:
    std::unique_ptr<SimpleNode> m_simpleNode;

public:
    template <typename TPort, typename... Args>
    auto make_port(Args&&... args)
    {
        return m_simpleNode->make_port<TPort>(std::forward<Args>(args)...);
    }

    template <typename NodeT, size_t PortIndex, typename... Args>
    void initInputPort(Args&&... args)
    {
        m_simpleNode->initInputPort<NodeT, PortIndex>(std::forward<Args>(args)...);
    }

    template <typename NodeT, size_t PortIndex, typename... Args>
    void initInputArrayPort(Args&&... args)
    {
        m_simpleNode->initInputArrayPort<NodeT, PortIndex>(std::forward<Args>(args)...);
    }

    template <typename NodeT, size_t PortIndex, typename... Args>
    void initOutputPort(Args&&... args)
    {
        m_simpleNode->initOutputPort<NodeT, PortIndex>(std::forward<Args>(args)...);
    }

    template <typename NodeT, size_t PortIndex, typename... Args>
    void initOutputArrayPort(Args&&... args)
    {
        m_simpleNode->initOutputArrayPort<NodeT, PortIndex>(std::forward<Args>(args)...);
    }

    template <typename NodeT, size_t PortIndex>
    auto& getInputPort()
    {
        return m_simpleNode->getInputPort<NodeT, PortIndex>();
    }

    template <typename NodeT, size_t PortIndex>
    auto& getInputPort(size_t arrayIndex)
    {
        return m_simpleNode->getInputPort<NodeT, PortIndex>(arrayIndex);
    }

    template <typename NodeT, size_t PortIndex>
    auto& getOutputPort()
    {
        return m_simpleNode->getOutputPort<NodeT, PortIndex>();
    }

    template <typename NodeT, size_t PortIndex>
    auto& getOutputPort(size_t arrayIndex)
    {
        return m_simpleNode->getOutputPort<NodeT, PortIndex>(arrayIndex);
    }

    const dw::core::HeapHashMap<size_t, std::shared_ptr<PortBase>>& getRegisteredInputPorts() const
    {
        return m_simpleNode->getRegisteredInputPorts();
    }

    const dw::core::HeapHashMap<size_t, std::shared_ptr<PortBase>>& getRegisteredOutputPorts() const
    {
        return m_simpleNode->getRegisteredOutputPorts();
    }

    dwStatus setIterationCount(uint32_t iterationCount) override
    {
        return m_simpleNode->setIterationCount(iterationCount);
    }

    uint32_t getIterationCount() const
    {
        return m_simpleNode->getIterationCount();
    }
};

class SimpleProcessNode : public ProcessNode
{
public:
    static constexpr char LOG_TAG[] = "SimpleProcessNode";

    SimpleProcessNode();
    SimpleProcessNode(NodeAllocationParams params);
    ~SimpleProcessNode() override = default;

    dwStatus run() override;
    size_t getPassCount() const noexcept override;
    dwStatus runPassByID(uint8_t passID) override;
    dwStatus runPass(size_t passIndex) override;
    dwStatus getPasses(VectorFixed<Pass*>& passList) override;
    dwStatus getPasses(VectorFixed<Pass*>& passList, dwProcessorType processorType, dwProcessType processType) override;

    dwStatus setName(const char* name) override;
    dwStatus getName(const char** name) override;

    dwStatus getHealthSignals(dwGraphHealthSignalArray*& healthSignals) override;

    dwStatus reset() override
    {
        throw Exception(DW_NOT_IMPLEMENTED, "Not implemented");
    }

    dwStatus setInputChannel(ChannelObject* channel, uint8_t portID) override;

    dwStatus setInputChannel(ChannelObject* channel, uint8_t portID, dwSerializationType serialType) override;

    dwStatus setOutputChannel(ChannelObject* channel, uint8_t portID) override;

    dwStatus validate() override
    {
        throw Exception(DW_NOT_IMPLEMENTED, "Not implemented");
    }

    dwStatus validate(const char* direction, const PortCollectionDescriptor& collection, const dw::core::HeapHashMap<size_t, std::shared_ptr<PortBase>>& ports, size_t indexOffset = 0)
    {
        return m_simpleNode->validate(direction, collection, ports, indexOffset);
    }

protected:
    virtual std::unique_ptr<Pass> createSetupPass()
    {
        throw Exception(DW_NOT_IMPLEMENTED, "Not implemented");
    }

    virtual std::unique_ptr<Pass> createTeardownPass()
    {
        throw Exception(DW_NOT_IMPLEMENTED, "Not implemented");
    }

    dwStatus setup()
    {
        return m_simpleNode->setup();
    }

    dwStatus teardown()
    {
        return m_simpleNode->teardown();
    }

    void resetPorts()
    {
        m_simpleNode->resetPorts();
    }

    template <typename ModuleHandle_t>
    dwStatus setModuleHandle(ModuleHandle_t handle, dwContextHandle_t context)
    {
        return m_simpleNode->template setModuleHandle<>(handle, context);
    }

    dwStatus setObjectHandle(dwModuleHandle_t handle);

    template <typename PassFunctionT, typename... Args>
    std::unique_ptr<PassImpl<PassFunctionT>> make_pass(PassFunctionT func, Args&&... args)
    {
        return m_simpleNode->make_pass_with_node(this, func, std::forward<Args>(args)...);
    }

    template <
        typename NodeT, size_t PassIndex, typename PassFunctionT>
    void registerPass(PassFunctionT func, NvMediaDla* dlaEngine = nullptr)
    {
        m_simpleNode->registerPassWithNode<NodeT, PassIndex>(this, func, dlaEngine);
    }

    void addPass(Pass* pass);

    dwStatus clearHealthSignals();

    dwStatus addHealthSignal(const dwGraphHealthSignal& signal);

    std::atomic<bool> m_asyncResetFlag;

private:
    std::shared_ptr<SimpleNode> m_simpleNode;

public:
    template <typename TPort, typename... Args>
    auto make_port(Args&&... args)
    {
        return m_simpleNode->make_port<TPort>(std::forward<Args>(args)...);
    }

    template <typename NodeT, size_t PortIndex, typename... Args>
    void initInputPort(Args&&... args)
    {
        m_simpleNode->initInputPort<NodeT, PortIndex>(std::forward<Args>(args)...);
    }

    template <typename NodeT, size_t PortIndex, typename... Args>
    void initInputArrayPort(Args&&... args)
    {
        m_simpleNode->initInputArrayPort<NodeT, PortIndex>(std::forward<Args>(args)...);
    }

    template <typename NodeT, size_t PortIndex, typename... Args>
    void initOutputPort(Args&&... args)
    {
        m_simpleNode->initOutputPort<NodeT, PortIndex>(std::forward<Args>(args)...);
    }

    template <typename NodeT, size_t PortIndex, typename... Args>
    void initOutputArrayPort(Args&&... args)
    {
        m_simpleNode->initOutputArrayPort<NodeT, PortIndex>(std::forward<Args>(args)...);
    }

    template <typename NodeT, size_t PortIndex>
    auto& getInputPort()
    {
        return m_simpleNode->getInputPort<NodeT, PortIndex>();
    }

    template <typename NodeT, size_t PortIndex>
    auto& getInputPort(size_t arrayIndex)
    {
        return m_simpleNode->getInputPort<NodeT, PortIndex>(arrayIndex);
    }

    template <typename NodeT, size_t PortIndex>
    auto& getOutputPort()
    {
        return m_simpleNode->getOutputPort<NodeT, PortIndex>();
    }

    template <typename NodeT, size_t PortIndex>
    auto& getOutputPort(size_t arrayIndex)
    {
        return m_simpleNode->getOutputPort<NodeT, PortIndex>(arrayIndex);
    }

    const dw::core::HeapHashMap<size_t, std::shared_ptr<PortBase>>& getRegisteredInputPorts() const
    {
        return m_simpleNode->getRegisteredInputPorts();
    }

    const dw::core::HeapHashMap<size_t, std::shared_ptr<PortBase>>& getRegisteredOutputPorts() const
    {
        return m_simpleNode->getRegisteredOutputPorts();
    }

    dwStatus setIterationCount(uint32_t iterationCount) override
    {
        return m_simpleNode->setIterationCount(iterationCount);
    }

    uint32_t getIterationCount() const
    {
        return m_simpleNode->getIterationCount();
    }
};

} // namespace framework
} // namespace dw

#endif // DW_FRAMEWORK_SIMPLENODE_HPP_