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-2021 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/base/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 getHealthSignals(dwGraphHealthSignalArray*& healthSignals) = 0;

    virtual dwStatus setIterationCount(uint32_t iterationCount) = 0;
};

class ProcessNode : public Node
{
public:
    ~ProcessNode() override = default;
};

class SensorNode : public Node
{
public:
    ~SensorNode() override = default;

    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 IContainsPreShutdownAction
{
public:
    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 dwStatus setAsyncReset() = 0;
    virtual dwStatus executeAsyncReset() = 0;
};


} // namespace framework
} // namespace dw

#include "impl/ExceptionSafeNode.hpp"

#endif //DW_FRAMEWORK_BASECLASS_NODE_HPP_