node.h

Go to the documentation of this file.

//
// Copyright 2025 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_EXEC_VDF_NODE_H
#define PXR_EXEC_VDF_NODE_H
 
 
#include "pxr/pxr.h"
 
#include "pxr/exec/vdf/api.h"
#include "pxr/exec/vdf/connectorMap.h"
#include "pxr/exec/vdf/connectorSpecs.h"
#include "pxr/exec/vdf/input.h"
#include "pxr/exec/vdf/inputAndOutputSpecs.h"
#include "pxr/exec/vdf/mask.h"
#include "pxr/exec/vdf/output.h"
#include "pxr/exec/vdf/request.h"
#include "pxr/exec/vdf/types.h"
 
#include "pxr/base/arch/demangle.h"
#include "pxr/base/arch/functionLite.h"
#include "pxr/base/tf/iterator.h"
#include "pxr/base/tf/mallocTag.h"
#include "pxr/base/tf/token.h"
 
#include <functional>
#include <string>
#include <typeinfo>
#include <type_traits>
#include <utility>
#include <vector>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class VdfContext;
class VdfExecutorInterface;
class VdfMaskedOutput;
class VdfNetwork;
class VdfRequiredInputsPredicate;
class VdfVector;
 
class VDF_API_TYPE VdfNode 
{
private:
 
    // Map of tokens to output connectors.
    //
    using _TokenOutputMap = VdfConnectorMap<VdfOutput>;
 
    // Map of tokens to input connectors.
    //
    using _TokenInputMap = VdfConnectorMap<VdfInput>;
 
public:
 
    TF_MALLOC_TAG_NEW("Vdf", "new VdfNode");
 
    // This little class allows clients to use TF_FOR_ALL to iterate
    // through the input connectors.
    //
    class InputMapIterator {
    public:
        typedef _TokenInputMap::const_iterator const_iterator;
        typedef _TokenInputMap::const_reverse_iterator const_reverse_iterator;
 
        InputMapIterator(const _TokenInputMap &map) : _map(map) {}
        const_iterator begin() const { return _map.begin(); }
        const_iterator end() const { return _map.end(); }
        const_reverse_iterator rbegin() const { return _map.rbegin(); }
        const_reverse_iterator rend() const { return _map.rend(); }
 
    private:
        const _TokenInputMap &_map;
    };
 
    // This little class allows clients to use TF_FOR_ALL to iterate
    // through the output connectors.
    //
    class OutputMapIterator {
    public:
        typedef _TokenOutputMap::const_iterator const_iterator;
        typedef _TokenOutputMap::const_reverse_iterator const_reverse_iterator;
 
        OutputMapIterator(const _TokenOutputMap &map) : _map(map) {}
        const_iterator begin() const { return _map.begin(); }
        const_iterator end() const { return _map.end(); }
        const_reverse_iterator rbegin() const { return _map.rbegin(); }
        const_reverse_iterator rend() const { return _map.rend(); }
 
    private:
        const _TokenOutputMap &_map;
    };
 
 
    VDF_API
    VdfNode(VdfNetwork *network,
            const VdfInputSpecs &inputSpecs,
            const VdfOutputSpecs &outputSpecs);
 
    VdfId GetId() const { return _id; }
 
    static VdfIndex GetIndexFromId(const VdfId id) {
        return static_cast<VdfIndex>(id);
    }
 
    static VdfVersion GetVersionFromId(const VdfId id) {
        return static_cast<VdfVersion>(id >> 32);
    }
 
    const VdfNetwork &GetNetwork() const { return _network; }
 
    VdfNetwork &GetNetwork() { return _network; }
 
    template<typename TYPE>
    bool IsA() const
    {
        return dynamic_cast<const TYPE *>(this);
    }
 
 
    const VdfInputSpecs &GetInputSpecs() const {
        return _specs->GetInputSpecs();
    }
 
    const VdfInput *GetInput(const TfToken &inputName) const {
        return const_cast<VdfNode *>(this)->GetInput(inputName);
    }
 
    VDF_API
    VdfInput *GetInput(const TfToken &inputName);
 
    const InputMapIterator GetInputsIterator() const { 
        return InputMapIterator(_inputs);
    }
 
    bool HasInputConnections() const {
        TF_FOR_ALL(i, _inputs) {
            if (i->second->GetNumConnections())
                return true;
        }
        return false;
    }
 
    bool HasOutputConnections() const {
        TF_FOR_ALL(output, _outputs) {
            if (output->second->GetConnections().size())
                return true;
        }
        return false;
    }
 
    VDF_API
    VdfConnectionVector GetInputConnections() const;
 
    VDF_API
    VdfConnectionVector GetOutputConnections() const;
 
 
 
 
    const VdfOutputSpecs &GetOutputSpecs() const {
        return _specs->GetOutputSpecs();
    }
 
    const VdfOutput *GetOutput(const TfToken &name) const {
        return const_cast<VdfNode *>(this)->GetOutput(name);
    }
 
    VDF_API
    VdfOutput *GetOutput(const TfToken &name);
 
    VDF_API
    VdfOutput *GetOptionalOutput(const TfToken &name);
 
    const VdfOutput *GetOptionalOutput(const TfToken &name) const {
        return const_cast<VdfNode *>(this)->GetOptionalOutput(name);
    }
 
    const VdfOutput *GetOutput() const {
        return const_cast<VdfNode *>(this)->GetOutput();
    }
 
    VDF_API
    VdfOutput *GetOutput();
 
    const OutputMapIterator GetOutputsIterator() const { 
        return OutputMapIterator(_outputs);
    }
 
    size_t GetNumOutputs() const {
        return _outputs.size();
    }
 
    size_t GetNumInputs() const {
        return _inputs.size();
    }
 
 
 
 
    VDF_API
    void SetDebugName(const std::string &name);
 
    template <class F>
    void SetDebugNameCallback(F &&f) {
        TfAutoMallocTag tag("Vdf", __ARCH_PRETTY_FUNCTION__);
        SetDebugNameCallback(VdfNodeDebugNameCallback(std::forward<F>(f)));
    }
 
    VDF_API
    void SetDebugNameCallback(VdfNodeDebugNameCallback &&callback);
 
    VDF_API
    const std::string GetDebugName() const;
 
    VDF_API
    virtual size_t GetMemoryUsage() const;
 
 
 
    
    virtual void Compute(const VdfContext &context) const = 0;
 
    VDF_API
    virtual bool IsSpeculationNode() const;
 
    VDF_API
    virtual VdfRequiredInputsPredicate GetRequiredInputsPredicate(
        const VdfContext &context) const;
 
    VDF_API
    VdfMask ComputeOutputDependencyMask(
        const VdfConnection &inputConnection,
        const VdfMask &inputDependencyMask,
        const VdfOutput &output) const;
 
    VDF_API
    void ComputeOutputDependencyMasks(
        const VdfConnection &inputConnection,
        const VdfMask &inputDependencyMask,
        VdfMaskedOutputVector *outputDependencies) const;
 
    VDF_API
    VdfMask::Bits ComputeInputDependencyMask(
        const VdfMaskedOutput &maskedOutput,
        const VdfConnection &inputConnection) const;
 
    VDF_API
    VdfConnectionAndMaskVector ComputeInputDependencyMasks(
        const VdfMaskedOutput &maskedOutput,
        bool skipAssociatedInputs) const;
 
    VDF_API
    VdfConnectionAndMaskVector ComputeInputDependencyRequest(
        const VdfMaskedOutputVector &request) const;
 
 
 
    VDF_API
    bool IsEqual(const VdfNode &rhs) const;
 
protected:
 
    VDF_API
    VdfNode(VdfNetwork *network);
 
    VDF_API
    void _AppendInputs(
        const VdfInputSpecs &inputSpecs,
        std::vector<VdfInput*> *resultingInputs = NULL);
 
    VDF_API
    void _AppendOutputs(
        const VdfOutputSpecs &outputSpecs,
        std::vector<VdfOutput*> *resultingOutputs = NULL);
 
    VDF_API
    virtual bool _IsDerivedEqual(const VdfNode &rhs) const;
 
    VDF_API
    virtual void _DidAddInputConnection(const VdfConnection *c, int atIndex);
 
    VDF_API
    virtual void _WillRemoveInputConnection(const VdfConnection *c);
 
    // The network is the only entity allowed to delete a node and set a node's
    // id.
    friend class VdfNetwork;
    
    VDF_API
    virtual ~VdfNode();
 
    void _SetId(const VdfVersion version, const VdfIndex index) {
        _id = (static_cast<VdfId>(version) << 32) | static_cast<VdfId>(index);
    }
 
 
    VDF_API
    virtual const VdfInputAndOutputSpecs *_AcquireInputAndOutputSpecsPointer(
        const VdfInputSpecs &inputSpecs,
        const VdfOutputSpecs &outputSpecs);
 
    VDF_API
    virtual void _ReleaseInputAndOutputSpecsPointer(
        const VdfInputAndOutputSpecs *specs);
 
    VDF_API
    void _InitializeInputAndOutputSpecs(
        const VdfInputAndOutputSpecs *specs);
 
    VDF_API
    void _ClearInputAndOutputSpecsPointer();
 
    VDF_API
    void _ReplaceInputSpecs(const VdfInputSpecs &inputSpecs);
 
 
    template <typename BaseClassType, typename ClassType>
    static size_t _GetMemoryUsage(const ClassType &c, size_t dynamicSize)
    {
        return c.BaseClassType::GetMemoryUsage() + 
            (sizeof(ClassType) - sizeof(BaseClassType)) + 
            dynamicSize;
    }
 
    VDF_API
    virtual VdfMask _ComputeOutputDependencyMask(
        const VdfConnection &inputConnection,
        const VdfMask &inputDependencyMask,
        const VdfOutput &output) const;
 
    VDF_API
    virtual bool _ComputeOutputDependencyMasks(
        const VdfConnection &inputConnection,
        const VdfMask &inputDependencyMask,
        VdfMaskedOutputVector *outputDependencies) const;
 
    VDF_API
    virtual VdfConnectionAndMaskVector _ComputeInputDependencyRequest(
        const VdfMaskedOutputVector &request) const;
 
    VDF_API
    virtual VdfMask::Bits _ComputeInputDependencyMask(
        const VdfMaskedOutput &maskedOutput,
        const VdfConnection &inputConnection) const;
 
    VDF_API
    virtual VdfConnectionAndMaskVector _ComputeInputDependencyMasks(
        const VdfMaskedOutput &maskedOutput,
        bool skipAssociatedInputs) const;
 
private:
 
    // This is the network to which the node belongs.
    // XXX:memory
    // We may want to come up with a better scheme than adding a back pointer
    // per-node!
    VdfNetwork &_network;
 
    // This is the unique id of this node in its network.
    VdfId _id;
 
    // This object holds on to the specs of the input and output connectors.
    // This object is never owned by VdfNode.  In the base implementation,
    // this object is owned by Vdf_InputAndOutputSpecsRegistry and must be
    // acquired and released through this object.  Derived classes may provide
    // their own management of this pointer.
    const VdfInputAndOutputSpecs *_specs;
 
    // The list of inputs.  _inputs[i] gives you all the links into 
    // the i-th input of this node.
    _TokenInputMap _inputs;
 
    // The list of outputs.  _outputs[name] gives you all the links out of
    // the output connector of this node with the label name.
    //
    // We require _outputs.size() be constant time.
    _TokenOutputMap _outputs;
};
 
template <>
struct Tf_ShouldIterateOverCopy<VdfNode::InputMapIterator> : std::true_type {};
template <>
struct Tf_ShouldIterateOverCopy<VdfNode::OutputMapIterator> : std::true_type {};
 
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif