Node.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) 2017-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_BASECLASS_NODE_HPP_
#define DW_FRAMEWORK_BASECLASS_NODE_HPP_
 
#include <map>
 
#include <dw/core/base/Types.h>
#include <dw/core/context/ObjectExtra.h>
 
#include <dwcgf/Types.hpp>
#include <dwcgf/channel/Channel.hpp>
#include <dwcgf/pass/Pass.hpp>
#include <dwcgf/logger/Logger.hpp>
#include <dwcgf/computegraph/GraphHealthSignal.hpp>
#include <dw/core/container/VectorFixed.hpp>
#include <dw/core/container/BaseString.hpp>
 
#include <string>
#include <memory>
#include <atomic>
 
namespace dw
{
namespace framework
{
using dw::core::FixedString;
using dw::core::VectorFixed;
class ParameterProvider;
 
#define _DW_CGF_STRINGIFY(x) #x
// std::char_traits<char8_t>::length() is not constexpr before C++17, use "sizeof() - 1" as WAR
#define STRING_VIEW_OF_FIXED_STRING_TEMPLATE_TYPE(x) dw::core::StringView("dw::core::FixedString<" _DW_CGF_STRINGIFY(x) ">", sizeof("dw::core::FixedString<" _DW_CGF_STRINGIFY(x) ">") - 1)
 
class Node
{
public:
    static constexpr size_t MAX_NAME_LEN = 128;
    using Name_t                         = FixedString<MAX_NAME_LEN>;
 
    static constexpr uint32_t MAX_PORT_COUNT = 256;
 
    static constexpr uint32_t MAX_PASS_COUNT = 256;
    static constexpr uint8_t PASS_SETUP      = std::numeric_limits<uint8_t>::max() - 1;
    static constexpr uint8_t PASS_TEARDOWN   = std::numeric_limits<uint8_t>::max();
 
    virtual ~Node() = default;
 
    virtual dwStatus reset() = 0;
 
    virtual dwStatus setInputChannel(ChannelObject* channel, uint8_t portID) = 0;
 
    virtual dwStatus setInputChannel(ChannelObject* channel, uint8_t portID, dwSerializationType dataType) = 0;
 
    virtual dwStatus setOutputChannel(ChannelObject* channel, uint8_t portID) = 0;
 
    virtual dwStatus validate() = 0;
 
    virtual dwStatus run() = 0;
 
    virtual size_t getPassCount() const noexcept = 0;
 
    virtual dwStatus runPassByID(uint8_t passID) = 0;
 
    virtual dwStatus runPass(size_t passIndex) = 0;
 
    virtual dwStatus getPasses(VectorFixed<Pass*>& passList) = 0;
 
    virtual dwStatus getPasses(VectorFixed<Pass*>& passList,
                               dwProcessorType processorType,
                               dwProcessType processType) = 0;
 
    virtual dwStatus setName(const char* name) = 0;
 
    virtual dwStatus getName(const char** name) = 0;
 
    virtual dwStatus getErrorSignal(dwGraphErrorSignal*& errorSignal) = 0;
 
    virtual dwStatus getHealthSignal(dwGraphHealthSignal*& healthSignals, bool updateFromModule = false) = 0;
 
    virtual dwStatus reportCurrentErrorSignal(dwGraphErrorSignal& signal) = 0;
 
    virtual dwStatus reportCurrentHealthSignal(dwGraphHealthSignal& signal) = 0;
 
    virtual dwStatus setIterationCount(uint32_t iterationCount) = 0;
 
    virtual dwStatus setState(const char* state) = 0;
 
    virtual void resetPorts() = 0;
};
 
class ISensorNode
{
public:
    virtual dwStatus start() = 0;
 
    virtual dwStatus stop() = 0;
 
    virtual dwStatus setAffinityMask(uint) = 0;
 
    virtual dwStatus setThreadPriority(int) = 0;
 
    virtual dwStatus setStartTime(dwTime_t) = 0;
 
    virtual dwStatus setEndTime(dwTime_t) = 0;
 
    virtual dwStatus isVirtual(bool* isVirtualBool) = 0;
 
    enum class DataEventType
    {
        PRODUCE, // sensor node produces data for a node-run
        DROP,    // sensor node drops data in the next node-run
        NONE,    // sensor node does not produce data for a node-run
    };
 
    struct DataEvent
    {
        DataEventType dataEventType;
        dwStatus status;
        dwTime_t timestamp;
    };
 
    using DataEventReadCallback = dw::core::Function<bool(DataEvent&)>;
    virtual dwStatus setDataEventReadCallback(DataEventReadCallback cb) = 0;
 
    using DataEventWriteCallback = dw::core::Function<void(DataEvent)>;
    virtual dwStatus setDataEventWriteCallback(DataEventWriteCallback cb) = 0;
};
 
class SensorNode
{
public:
    using DataEventType = ISensorNode::DataEventType;
 
    using DataEvent = ISensorNode::DataEvent;
 
    using DataEventReadCallback = ISensorNode::DataEventReadCallback;
 
    using DataEventWriteCallback = ISensorNode::DataEventWriteCallback;
 
    SensorNode(Node* node)
        : m_node(node)
        , m_sensorNode(dynamic_cast<ISensorNode*>(node))
    {
        if (m_sensorNode != nullptr)
        {
            throw Exception(DW_INVALID_ARGUMENT, "Passed node pointer does not implement ISensorNode.");
        }
    }
 
    Node* getNode()
    {
        return m_node;
    }
 
    Node const* getNode() const
    {
        return m_node;
    }
 
    ISensorNode* getSensorNode()
    {
        return m_sensorNode;
    }
 
    ISensorNode const* getSensorNode() const
    {
        return m_sensorNode;
    }
 
private:
    Node* m_node{};
    ISensorNode* m_sensorNode{};
};
 
class IContainsPreShutdownAction
{
public:
    virtual ~IContainsPreShutdownAction() = default;
 
    virtual dwStatus preShutdown() = 0;
};
 
// TODO(ajayawardane) WAR: When there is a single SSM pass in the graph, reset could potentially
// be called while node passes are running. Until STM schedule re-entry is supported, we reset the
// supported nodes in the setup pass.
class IAsyncResetable
{
public:
    virtual ~IAsyncResetable() = default;
 
    virtual dwStatus setAsyncReset() = 0;
    virtual dwStatus executeAsyncReset() = 0;
};
 
class IChannelsConnectedListener
{
public:
    virtual ~IChannelsConnectedListener() = default;
 
    virtual void onChannelsConnected() = 0;
};
 
 
} // namespace framework
} // namespace dw
 
#include "impl/ExceptionSafeNode.hpp"
 
#endif // DW_FRAMEWORK_BASECLASS_NODE_HPP_