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-2023 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 <dwshared/dwfoundation/dw/core/container/BaseString.hpp>
#include <dwshared/dwfoundation/dw/core/container/HashContainer.hpp>
#include <dwshared/dwfoundation/dw/core/container/VectorFixed.hpp>
#include <dwshared/dwfoundation/dw/core/language/Function.hpp>
 
#include <memory>
 
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>
// coverity[autosar_cpp14_a2_10_5_violation] FP: nvbugs/3907242
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:
    SimpleNode();
    SimpleNode(NodeAllocationParams params);
    virtual ~SimpleNode();
 
    dwStatus reset() override
    {
        throw ExceptionWithStatus(DW_NOT_IMPLEMENTED, "SimpleNode::reset() not implemented");
    }
 
 
    dwStatus setInputChannel(ChannelObject* channel, uint8_t portID) override;
 
    dwStatus setInputChannel(ChannelObject*, uint8_t, dwSerializationType) override
    {
        throw ExceptionWithStatus(DW_NOT_IMPLEMENTED, "SimpleNode::setInputChannel() not implemented");
    }
 
 
    dwStatus setOutputChannel(ChannelObject* channel, uint8_t portID) override;
 
    dwStatus getInputChannel(const uint8_t portID, ChannelObject*& channel) const override;
 
    dwStatus getOutputChannel(const uint8_t portID, ChannelObject*& channel) const override;
 
    dwStatus validate() override
    {
        throw ExceptionWithStatus(DW_NOT_IMPLEMENTED, "SimpleNode::validate() not implemented");
    }
 
 
    dwStatus validate(const char* direction, const PortCollectionDescriptor& collection, dw::core::Function<bool(size_t)> isPortBound);
 
    dwStatus run() override;
    size_t getPassCount() const noexcept override;
    dwStatus runPass(size_t passIndex) override;
    dwStatus getPass(Pass** pass, uint8_t index) override;
    // coverity[autosar_cpp14_a2_10_5_violation]
    dwStatus getPasses(VectorFixed<Pass*>& passList) override;
    // coverity[autosar_cpp14_a2_10_5_violation]
    dwStatus getPasses(VectorFixed<Pass*>& passList, dwProcessorType processorType) override;
 
    dwStatus setName(const char* name) final;
    dwStatus getName(const char** name) override;
 
    dwStatus getErrorSignal(dwGraphErrorSignal& sehErrorSignal, dwGraphErrorSignal*& errorSignal, uint16_t const sourceId, char8_t const* instanceName = nullptr) override;
    dwStatus getHealthSignal(dwGraphHealthSignal*& healthSignals, bool updateFromModule = false) override;
    dwStatus clearErrorSignal() override;
    dwStatus clearHealthSignal() 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 (elem.second.get() == nullptr)
            {
                const char* nodeName{nullptr};
                this->getName(&nodeName);
                throw ExceptionWithStatus(DW_NOT_INITIALIZED, "SimpleNode: input port not initialized, node ", nodeName, ", port id ", elem.first);
            }
            func(*elem.second);
        });
    }
 
    template <typename Func>
    void iterateManagedOutputPorts(Func func)
    {
        iteratePorts(m_outputPorts, [&func, this](decltype(m_outputPorts)::TElement& elem) {
            if (elem.second.get() == nullptr)
            {
                const char* nodeName{nullptr};
                this->getName(&nodeName);
                throw ExceptionWithStatus(DW_NOT_INITIALIZED, "SimpleNode: output port not initialized, node ", nodeName, ", port id ", elem.first);
            }
            func(*elem.second);
        });
    }
 
    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);
 
    dwStatus getInputPort(const uint8_t portID, dw::framework::PortBase*& port) const override;
 
    dwStatus getOutputPort(const uint8_t portID, dw::framework::PortBase*& port) const override;
 
protected:
    dwStatus getModuleHandle(dwModuleHandle_t* moduleHandle, void* handle, dwContextHandle_t context);
 
    virtual std::unique_ptr<Pass> createSetupPass()
    {
        throw ExceptionWithStatus(DW_NOT_IMPLEMENTED, "SimpleNode::createSetupPass() not implemented");
    }
 
    virtual std::unique_ptr<Pass> createTeardownPass()
    {
        throw ExceptionWithStatus(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, std::initializer_list<std::pair<dwStatus, uint32_t>> const& returnMapping = {})
    {
        // coverity[autosar_cpp14_a5_1_1_violation]
        if (!isValidPass<NodeT>(PassIndex))
        {
            throw ExceptionWithStatus(DW_INVALID_ARGUMENT, "registerPass called with an invalid pass id: ", PassIndex);
        }
        // coverity[autosar_cpp14_a5_1_1_violation] RFD Accepted: TID-2056
        if (m_passList.size() == 0U || m_passList.size() - 1U < PassIndex)
        {
            // coverity[autosar_cpp14_a5_1_1_violation] RFD Accepted: TID-2056
            m_passList.resize(PassIndex + 1U);
            // coverity[autosar_cpp14_a5_1_1_violation] RFD Accepted: TID-2056
            m_passOwnershipList.resize(PassIndex + 1U);
        }
        // coverity[autosar_cpp14_a5_1_1_violation]
        if (m_passList[PassIndex] != nullptr)
        {
            throw ExceptionWithStatus(DW_INVALID_ARGUMENT, "registerPass called with a pass id which has been added before: ", PassIndex);
        }
        dwProcessorType processorType{passProcessorType<NodeT, PassIndex>()};
        // coverity[autosar_cpp14_a5_1_1_violation]
        m_passList[PassIndex] = std::make_unique<PassImpl<PassFunctionT>>(*this, func, processorType, returnMapping);
        // coverity[autosar_cpp14_a5_1_1_violation]
        m_passOwnershipList[PassIndex] = true;
    }
 
 
    template <
        typename NodeT, size_t PassIndex, typename PassFunctionT>
    void registerPass(PassFunctionT func, cudaStream_t const cudaStream, std::initializer_list<std::pair<dwStatus, uint32_t>> const& returnMapping = {})
    {
        static_assert(passProcessorType<NodeT, PassIndex>() == DW_PROCESSOR_TYPE_GPU, "The processor type of a pass with a cuda stream must be GPU");
        registerPass<NodeT, PassIndex>(func, returnMapping);
        m_passList[PassIndex]->m_cudaStream = cudaStream;
    }
 
public:
    void addPass(Pass* pass);
 
    dwStatus updateHealthSignal(const dwGraphHealthSignal& signal);
 
    dwStatus copyModuleHealthSignals(dwHealthSignal& outSignal);
 
    dwStatus updateCurrentErrorSignal(dwGraphErrorSignal& signal) override;
 
    dwStatus updateCurrentHealthSignal(dwGraphHealthSignal& signal) override;
 
private:
    dwStatus updateHealthSignalFromModule();
 
    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;
 
    dwGraphErrorSignal m_errorSignal;
    dwGraphHealthSignal m_healthSignal;
 
    dwModuleHandle_t m_object;
    uint32_t m_iterationCount{};
    uint32_t m_nodePeriod{};
 
public:
    template <typename TPort, typename... Args>
    std::unique_ptr<TPort> make_port(Args&&... args)
    {
        std::unique_ptr<TPort> 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)
    {
        static_assert(PortIndex < portSize<NodeT, PortDirection::INPUT>(), "Invalid port index");
        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 ExceptionWithStatus(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)
    {
        static_assert(PortIndex < portSize<NodeT, PortDirection::INPUT>(), "Invalid port index");
        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 ExceptionWithStatus(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)
    {
        static_assert(PortIndex - portSize<NodeT, PortDirection::INPUT>() < portSize<NodeT, PortDirection::OUTPUT>(), "Invalid port index");
        using DataType = decltype(portType<NodeT, PortDirection::OUTPUT, PortIndex>());
        std::shared_ptr<ManagedPortOutput<DataType>> port{std::make_shared<ManagedPortOutput<DataType>>(std::forward<Args>(args)...)};
        if (m_outputPorts.find(PortIndex) != m_outputPorts.end())
        {
            throw ExceptionWithStatus(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)
    {
        static_assert(PortIndex - portSize<NodeT, PortDirection::INPUT>() < portSize<NodeT, PortDirection::OUTPUT>(), "Invalid port index");
        using DataType = decltype(portType<NodeT, PortDirection::OUTPUT, PortIndex>());
        // coverity[autosar_cpp14_a0_1_1_violation]
        // coverity[autosar_cpp14_m0_1_4_violation]
        constexpr size_t descriptor_index{descriptorIndex<NodeT, PortDirection::OUTPUT, PortIndex>()};
        constexpr size_t arraySize{descriptorPortSize<NodeT, PortDirection::OUTPUT, descriptor_index>()};
        for (size_t i{0U}; i < arraySize; ++i)
        {
            std::shared_ptr<ManagedPortOutput<DataType>> port{std::make_shared<ManagedPortOutput<DataType>>(std::forward<Args>(args)...)};
            if (m_outputPorts.find(PortIndex + i) != m_outputPorts.end())
            {
                throw ExceptionWithStatus(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()
    {
        static_assert(PortIndex < portSize<NodeT, PortDirection::INPUT>(), "Invalid port index");
        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 ExceptionWithStatus(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 ExceptionWithStatus(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)
    {
        static_assert(PortIndex < portSize<NodeT, PortDirection::INPUT>(), "Invalid port index");
        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 ExceptionWithStatus(DW_INVALID_ARGUMENT, "The array index is out of bound: ", arrayIndex);
        }
        if (m_inputPorts.find(PortIndex + arrayIndex) == m_inputPorts.end())
        {
            throw ExceptionWithStatus(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 ExceptionWithStatus(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()
    {
        static_assert(PortIndex - portSize<NodeT, PortDirection::INPUT>() < portSize<NodeT, PortDirection::OUTPUT>(), "Invalid port index");
        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 ExceptionWithStatus(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 ExceptionWithStatus(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)
    {
        static_assert(PortIndex - portSize<NodeT, PortDirection::INPUT>() < portSize<NodeT, PortDirection::OUTPUT>(), "Invalid port index");
        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 ExceptionWithStatus(DW_INVALID_ARGUMENT, "The array index is out of bound: ", arrayIndex);
        }
        if (m_outputPorts.find(PortIndex + arrayIndex) == m_outputPorts.end())
        {
            throw ExceptionWithStatus(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 ExceptionWithStatus(DW_BAD_CAST, "Failed to cast the following output port to its declared type: ", PortIndex + arrayIndex);
        }
        return *port;
    }
 
 
    dwStatus setup();
 
 
    dwStatus teardown();
 
 
    void resetPorts() override;
 
    dwStatus setIterationCount(uint32_t iterationCount) override;
 
    dwStatus setNodePeriod(uint32_t period) override;
 
    const dw::core::HeapHashMap<size_t, std::shared_ptr<ManagedPortInputBase>>& getRegisteredInputPorts() const
    {
        return m_inputPorts;
    }
 
    const dw::core::HeapHashMap<size_t, std::shared_ptr<ManagedPortOutputBase>>& getRegisteredOutputPorts() const
    {
        return m_outputPorts;
    }
 
    uint32_t getIterationCount() const;
    uint32_t getNodePeriod() const;
    dwStatus setState(const char* state) override
    {
        static_cast<void>(state);
        return DW_SUCCESS;
    }
 
protected:
    dw::core::HeapHashMap<size_t, std::shared_ptr<ManagedPortInputBase>> m_inputPorts;
    dw::core::HeapHashMap<size_t, std::shared_ptr<ManagedPortOutputBase>> m_outputPorts;
 
    std::atomic<bool> m_asyncResetFlag;
};
 
// coverity[autosar_cpp14_a0_1_6_violation]
class SimpleSensorNode : public ISensorNode
{
public:
    dwStatus start() override
    {
        throw ExceptionWithStatus(DW_NOT_IMPLEMENTED, "SimpleSensorNode::start() not implemented");
    }
 
    dwStatus stop() override
    {
        throw ExceptionWithStatus(DW_NOT_IMPLEMENTED, "SimpleSensorNode::stop() not implemented");
    }
 
    dwStatus isVirtual(bool*) override
    {
        throw ExceptionWithStatus(DW_NOT_IMPLEMENTED, "SimpleSensorNode::isVirtual() not implemented");
    }
 
    dwStatus setDataEventReadCallback(DataEventReadCallback) override
    {
        throw ExceptionWithStatus(DW_NOT_IMPLEMENTED, "SimpleSensorNode::setDataEventReadCallback() not implemented");
    }
 
    dwStatus setDataEventWriteCallback(DataEventWriteCallback) override
    {
        throw ExceptionWithStatus(DW_NOT_IMPLEMENTED, "SimpleSensorNode::setDataEventWriteCallback() not implemented");
    }
};
 
// coverity[autosar_cpp14_a0_1_6_violation]
// coverity[autosar_cpp14_a12_1_6_violation]
class SimpleProcessNode : public SimpleNode
{
public:
    SimpleProcessNode();
    SimpleProcessNode(NodeAllocationParams params);
};
 
} // namespace framework
} // namespace dw
 
#endif // DW_FRAMEWORK_SIMPLENODE_HPP_