testUtils.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_TEST_UTILS_H
#define PXR_EXEC_VDF_TEST_UTILS_H
 
 
#include "pxr/pxr.h"
 
#include "pxr/exec/vdf/api.h"
#include "pxr/exec/vdf/dataManagerVector.h"
#include "pxr/exec/vdf/executionStats.h"
#include "pxr/exec/vdf/executionStatsProcessor.h"
#include "pxr/exec/vdf/inputVector.h"
#include "pxr/exec/vdf/iterator.h"
#include "pxr/exec/vdf/network.h"
#include "pxr/exec/vdf/parallelDataManagerVector.h"
#include "pxr/exec/vdf/parallelSpeculationExecutorEngine.h"
#include "pxr/exec/vdf/schedule.h"
#include "pxr/exec/vdf/speculationExecutor.h"
#include "pxr/exec/vdf/speculationExecutorEngine.h"
#include "pxr/exec/vdf/simpleExecutor.h"
 
#include "pxr/base/tf/hash.h"
#include "pxr/base/tf/hashmap.h"
#include "pxr/base/tf/token.h"
 
#include <functional>
#include <memory>
#include <string>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class VdfMask;
class VdfNode;
class VdfSpeculationNode;
 
 
namespace VdfTestUtils 
{
 
class VDF_API_TYPE CallbackNode : public VdfNode
{
public:
 
    using ValueFunction = void(const VdfContext &context);
 
    CallbackNode(
        VdfNetwork *network,
        const VdfInputSpecs &inputSpecs,
        const VdfOutputSpecs &outputSpecs,
        ValueFunction *const cb)
    :   VdfNode(network, inputSpecs, outputSpecs),
        _cb(cb) {}
 
    virtual void Compute(const VdfContext &context) const override {
        (*_cb)(context);
    }
 
protected:
 
    virtual ~CallbackNode() {}
 
    virtual bool _IsDerivedEqual(const VdfNode &rhs) const override {
        return false;
    }
 
private:
 
    ValueFunction *const _cb;
};
 
class OutputAccessor : public VdfIterator
{
public:
    OutputAccessor(const VdfContext &context) : _context(context) {}
 
    const VdfOutput *GetOutput() const {
        return _GetNode(_context).GetOutput();
    }
 
private:
    const VdfContext &_context;
 
};
 
class VDF_API_TYPE DependencyCallbackNode : public CallbackNode
{
public:
    using InputDependencyFunction = std::function<
        VdfMask::Bits (const VdfMaskedOutput &maskedOutput,
              const VdfConnection &inputConnection)>;
 
    using OutputDependencyFunction = std::function<
        VdfMask (const VdfConnection &inputConnection,
              const VdfMask &inputDependencyMask,
              const VdfOutput &output)>;
 
    DependencyCallbackNode(
        VdfNetwork                      *network,
        const VdfInputSpecs             &inputSpecs,
        const VdfOutputSpecs            &outputSpecs,
        ValueFunction                   *function,
        const InputDependencyFunction   &inputDependencyFunction,
        const OutputDependencyFunction  &outputDependencyFunction) :
        CallbackNode(network, inputSpecs, outputSpecs, function),
        _inputDependencyFunction(inputDependencyFunction),
        _outputDependencyFunction(outputDependencyFunction) {
    }
 
protected:
    virtual VdfMask::Bits _ComputeInputDependencyMask(
        const VdfMaskedOutput &maskedOutput,
        const VdfConnection &inputConnection) const {
        if (_inputDependencyFunction) {
            return _inputDependencyFunction(
                maskedOutput, inputConnection); 
        } else {
            return VdfNode::_ComputeInputDependencyMask(
                maskedOutput, inputConnection);
        }
    }
 
    virtual VdfMask _ComputeOutputDependencyMask(
        const VdfConnection &inputConnection,
        const VdfMask &inputDependencyMask,
        const VdfOutput &output) const {
        if (_outputDependencyFunction) {
            return _outputDependencyFunction(
                inputConnection, inputDependencyMask, output);
        } else {
            return VdfNode::_ComputeOutputDependencyMask(
                inputConnection, inputDependencyMask, output);
        }
    }
 
private:
    InputDependencyFunction _inputDependencyFunction;
    OutputDependencyFunction _outputDependencyFunction;
 
};
 
class VDF_API_TYPE NodeType 
{
public:
    VDF_API
    virtual ~NodeType();
    virtual VdfNode *NewNode(VdfNetwork *net) const = 0;
};
 
 
template<typename T>
class InputNodeType  : public NodeType
{
public:
    InputNodeType(size_t size) : _size(size) {}
 
    virtual VdfNode *NewNode(VdfNetwork *net) const
    {
        return new VdfInputVector<T>(net, _size);
    }
 
private:
 
    const size_t _size;
 
};
 
class CallbackNodeType : public NodeType
{
public:
 
    CallbackNodeType(CallbackNode::ValueFunction *function) :
        _function(function) {
    }
 
    virtual VdfNode *NewNode(VdfNetwork *net) const
    {
        return new DependencyCallbackNode(
            net, _inputSpecs, _outputSpecs, 
            _function, _inputDependencyFunction, _outputDependencyFunction);
    }
 
    template <typename T>
    CallbackNodeType &Read(const TfToken &name) {
        _inputSpecs.ReadConnector<T>(name);
        return *this;
    }
 
    template<typename T>
    CallbackNodeType &ReadWrite(const TfToken &name, const TfToken &outName) {
        _inputSpecs.ReadWriteConnector<T>(name, outName);
        _outputSpecs.Connector<T>(outName);
        return *this;
    }
 
    template<typename T>
    CallbackNodeType &Out(const TfToken &name) {
        _outputSpecs.Connector<T>(name);
        return *this;
    }
 
    CallbackNodeType &ComputeInputDependencyMaskCallback(
        const DependencyCallbackNode::InputDependencyFunction &function) {
        _inputDependencyFunction = function;
        return *this;
    }
 
    CallbackNodeType &ComputeOutputDependencyMaskCallback(
        const DependencyCallbackNode::OutputDependencyFunction &function) {
        _outputDependencyFunction = function;
        return *this;
    }
 
private:
 
    VdfInputSpecs _inputSpecs;
    VdfOutputSpecs _outputSpecs;
 
    CallbackNode::ValueFunction *_function;
    DependencyCallbackNode::InputDependencyFunction _inputDependencyFunction;
    DependencyCallbackNode::OutputDependencyFunction _outputDependencyFunction;
};
 
 
 
class Node 
{
private:
 
    // These are private helper classes to support connection creation.
 
    // Represents a node's input.
    class _NodeInput
    {
    public:
        VdfNode *inputNode;
        TfToken  inputName;
        VdfMask  inputMask;
    };
 
    // Represents a node's output.
    class _NodeOutput
    {
    public:
 
        VDF_API
        Node &operator>>(const _NodeInput &rhs);
 
        Node    *owner;
        TfToken  outputName;
    };
 
 
public:
 
    VDF_API
    Node &operator>>(const _NodeInput &rhs);
 
    VDF_API
    _NodeInput In(const TfToken &inputName, const VdfMask &inputMask);
 
    VDF_API
    _NodeOutput Output(const TfToken &outputName);
 
    template<typename T>
    Node &SetValue(int index, const T &val) {
        dynamic_cast<VdfInputVector<T> *>(_vdfNode)->SetValue(index, val);
        return *this;
    }
 
    operator VdfNode *() { return GetVdfNode(); }
 
    VdfNode *GetVdfNode() { return _vdfNode; }
 
    const VdfNode *GetVdfNode() const { return _vdfNode; }
 
    VdfOutput *GetOutput() const { return _vdfNode->GetOutput(); }
 
private:
 
    // Helper method to actually do the connection.
    //
    void _Connect(const _NodeInput &rhs, VdfOutput *output);
 
    friend class Network;
    friend class _NodeOutput;
 
    // The network for connection purposes.
    VdfNetwork *_network;
 
    // The underlying VdfNode that we represent.
    VdfNode *_vdfNode;
};
 
 
class Network
{
 
private:
    
    class VDF_API_TYPE _EditMonitor : public VdfNetwork::EditMonitor
    {    
    public:
 
        _EditMonitor(Network *network) : _network(network) {}
        
        VDF_API
        ~_EditMonitor();
    
    
        VDF_API
        void WillDelete(const VdfNode *node) override;
 
        VDF_API
        void WillClear() override;
 
        void DidConnect(const VdfConnection *connection) override {}
        void DidAddNode(const VdfNode *node) override {}
        void WillDelete(const VdfConnection *connection) override {}
 
 
    private:
        Network *_network;
    };
 
 
public:
 
    Network() : _editMonitor(this) {
        _network.RegisterEditMonitor(&_editMonitor);
    }
 
    ~Network() {
        _network.UnregisterEditMonitor(&_editMonitor);
    }
 
    VDF_API
    void Add(const std::string &nodeName, const NodeType &nodeType);
 
    VDF_API
    void Add(const std::string &nodeName, VdfNode *customNode);
 
    template <typename T>
    void AddInputVector(const std::string &nodeName, size_t size = 1) {
        Add(nodeName, InputNodeType<T>(size));
    }
 
    VDF_API
    Node &operator[](const std::string &nodeName);
 
    VDF_API
    const Node &operator[](const std::string &nodeName) const;
 
    VDF_API
    const std::string GetNodeName(const VdfId nodeId);
 
    VDF_API
    VdfConnection *GetConnection(const std::string &connectionName);
 
    VdfNetwork &GetNetwork() { return _network; }
 
    const VdfNetwork &GetNetwork() const { return _network; }
 
private:
 
    // Node class needs to publish _connections;
    friend class Node;
 
    // Nodes that have been created, indexed by their name.
    typedef TfHashMap<std::string, Node, TfHash> _StringToNodeMap;
    _StringToNodeMap _nodes;
 
    // The network that will contain the VdfNodes we create.
    VdfNetwork _network;
 
    // An EditMonitor that allows us to keep the Network in sync when Nodes
    // are deleted
    _EditMonitor _editMonitor;
};
 
 
 
 
class VDF_API_TYPE ExecutionStatsProcessor : public VdfExecutionStatsProcessor {
public:
 
    ExecutionStatsProcessor() : VdfExecutionStatsProcessor() {}
 
    VDF_API
    ~ExecutionStatsProcessor();
 
    typedef
        std::unordered_map<
            ExecutionStatsProcessor::ThreadId,
            std::vector<VdfExecutionStats::Event>>
        ThreadToEvents;
 
    ThreadToEvents events;
    std::vector<ExecutionStatsProcessor*> subStats;
 
protected:
    VDF_API
    void _ProcessEvent(
        VdfExecutionStatsProcessor::ThreadId threadId, 
        const VdfExecutionStats::Event& event) override;
 
    VDF_API
    void _ProcessSubStat(const VdfExecutionStats* stats) override;
};
 
 
class ExecutionStats {
public:
    
    ExecutionStats() : _stats(std::make_unique<_ExecutionStats>()) {}
 
    ~ExecutionStats() {}
 
    VDF_API
    void Log(VdfExecutionStats::EventType event, VdfId nodeId, uint64_t data);
 
    VDF_API
    void LogBegin(
        VdfExecutionStats::EventType event,
        VdfId nodeId,
        uint64_t data);
 
    VDF_API
    void LogEnd(
        VdfExecutionStats::EventType event,
        VdfId nodeId,
        uint64_t data);
 
    VDF_API
    void GetProcessedStats(VdfExecutionStatsProcessor* processor) const;
 
    VDF_API
    void AddSubStat(VdfId nodeId);
 
private:
    class _ExecutionStats : public VdfExecutionStats {
    public:
        _ExecutionStats() : VdfExecutionStats(&_network) {}
        ~_ExecutionStats() {}
 
        void Log(
            VdfExecutionStats::EventType event, 
            VdfId nodeId, 
            uint64_t data);
 
        void LogBegin(
            VdfExecutionStats::EventType event,
            VdfId nodeId,
            uint64_t data);
 
        void LogEnd(
            VdfExecutionStats::EventType event,
            VdfId nodeId,
            uint64_t data);
 
        void AddSubStat(VdfId nodeId);
 
    private:
        VdfNetwork _network;
    };
 
private:
    std::unique_ptr<_ExecutionStats> _stats;
};
 
inline std::unique_ptr<VdfSpeculationExecutorBase>
CreateSpeculationExecutor(
    const VdfSpeculationNode *speculationNode,
    const VdfExecutorInterface *parentExecutor) {
    // Multi-threaded executor.
    if (VdfIsParallelEvaluationEnabled()) {
        return std::unique_ptr<VdfSpeculationExecutorBase>(
            new VdfSpeculationExecutor<
                VdfParallelSpeculationExecutorEngine,
                VdfParallelDataManagerVector>(
                    speculationNode, parentExecutor));
    } 
 
    // Single-threaded executor.
    return std::unique_ptr<VdfSpeculationExecutorBase>(
        new VdfSpeculationExecutor<
            VdfSpeculationExecutorEngine,
            VdfDataManagerVector<VdfDataManagerDeallocationMode::Background> >(
                speculationNode, parentExecutor));
}
 
 
} // namespace VdfTestUtils
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif