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
{
 
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, "SimpleNode::reset() not implemented");
    }
 
 
    dwStatus setInputChannel(ChannelObject* channel, uint8_t portID) override;
 
    dwStatus setInputChannel(ChannelObject*, uint8_t, dwSerializationType) override
    {
        throw Exception(DW_NOT_IMPLEMENTED, "SimpleNode::setInputChannel() not implemented");
    }
 
 
    dwStatus setOutputChannel(ChannelObject* channel, uint8_t portID) override;
 
    dwStatus validate() override
    {
        throw Exception(DW_NOT_IMPLEMENTED, "SimpleNode::validate() 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 getErrorSignal(dwGraphErrorSignal*& errorSignal) override;
    dwStatus getHealthSignal(dwGraphHealthSignal*& healthSignals, bool updateFromModule = false) 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, "SimpleNode::createSetupPass() not implemented");
    }
 
    virtual std::unique_ptr<Pass> createTeardownPass()
    {
        throw Exception(DW_NOT_IMPLEMENTED, "SimpleNode::createTeardownPass() not implemented");
    }
 
    template <typename PassFunctionT, typename... Args>
    std::unique_ptr<PassImpl<PassFunctionT>> make_pass(PassFunctionT func, Args&&... args)
    {
        return std::make_unique<PassImpl<PassFunctionT>>(*this, func, std::forward<Args>(args)...);
    }
 
 
    template <
        typename NodeT, size_t PassIndex, typename PassFunctionT>
    void registerPass(PassFunctionT func, NvMediaDla* dlaEngine = nullptr)
    {
        if (!isValidPass<NodeT>(PassIndex))
        {
            throw Exception(DW_INVALID_ARGUMENT, "registerPass 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, "registerPass 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>>(*this, func, processorType, processType, -1, -1, -1);
        }
        else if (processorType == DW_PROCESSOR_TYPE_DLA_0)
        {
            m_passList[PassIndex] = std::make_unique<PassImpl<PassFunctionT>>(*this, func, processorType, processType, -1, -1, -1, dlaEngine);
        }
        else
        {
            throw Exception(DW_INVALID_ARGUMENT, "registerPass called with a pass which has dlaEngine but not a DLA pass: ", PassIndex);
        }
        m_passOwnershipList[PassIndex] = true;
    }
 
public:
    void addPass(Pass* pass);
 
    dwStatus clearHealthSignal();
 
    dwStatus updateHealthSignal(const dwGraphHealthSignal& signal);
 
    dwStatus copyModuleHealthSignals(dwHealthSignal& outSignal);
 
    dwStatus reportCurrentErrorSignal(dwGraphErrorSignal& signal) override;
 
    dwStatus reportCurrentHealthSignal(dwGraphHealthSignal& signal) override;
 
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;
    }
 
    dwStatus updateHealthSignalFromModule();
 
    uint16_t getInstanceIdFromName() const;
 
    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;
 
    dwGraphErrorSignal m_errorSignal{};
    dwGraphHealthSignal m_healthSignal{};
 
    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;
 
    dwStatus setState(const char* state) override
    {
        static_cast<void>(state);
        return DW_SUCCESS;
    }
 
protected:
    dw::core::HeapHashMap<size_t, std::shared_ptr<PortBase>> m_inputPorts;
    dw::core::HeapHashMap<size_t, std::shared_ptr<PortBase>> m_outputPorts;
 
    std::atomic<bool> m_asyncResetFlag{false};
};
 
class SimpleSensorNode : public ISensorNode
{
public:
    static constexpr char LOG_TAG[] = "SimpleSensorNode";
 
    dwStatus start() override
    {
        throw Exception(DW_NOT_IMPLEMENTED, "SimpleSensorNode::start() not implemented");
    }
 
    dwStatus stop() override
    {
        throw Exception(DW_NOT_IMPLEMENTED, "SimpleSensorNode::stop() not implemented");
    }
 
    dwStatus isVirtual(bool*) override
    {
        throw Exception(DW_NOT_IMPLEMENTED, "SimpleSensorNode::isVirtual() not implemented");
    }
 
    dwStatus setDataEventReadCallback(DataEventReadCallback) override
    {
        throw Exception(DW_NOT_IMPLEMENTED, "SimpleSensorNode::setDataEventReadCallback() not implemented");
    }
 
    dwStatus setDataEventWriteCallback(DataEventWriteCallback) override
    {
        throw Exception(DW_NOT_IMPLEMENTED, "SimpleSensorNode::setDataEventWriteCallback() not implemented");
    }
};
 
class SimpleProcessNode : public SimpleNode
{
public:
    SimpleProcessNode();
    SimpleProcessNode(NodeAllocationParams params);
};
 
} // namespace framework
} // namespace dw
 
#endif // DW_FRAMEWORK_SIMPLENODE_HPP_