speculationNode.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_SPECULATION_NODE_H
#define PXR_EXEC_VDF_SPECULATION_NODE_H
 
 
#include "pxr/pxr.h"
 
#include "pxr/exec/vdf/api.h"
#include "pxr/exec/vdf/connectorSpecs.h"
#include "pxr/exec/vdf/context.h"
#include "pxr/exec/vdf/node.h"
#include "pxr/exec/vdf/requiredInputsPredicate.h"
 
#include <tbb/concurrent_hash_map.h>
 
#include <memory>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class VdfSchedule;
 
class VDF_API_TYPE VdfSpeculationNode final : public VdfNode
{
public:
    VDF_API
    VdfSpeculationNode(
        VdfNetwork *network,
        const VdfInputSpecs &inputSpecs,
        const VdfOutputSpecs &outputSpecs);
 
    virtual bool IsSpeculationNode() const { return true; }
 
    virtual VdfRequiredInputsPredicate GetRequiredInputsPredicate(
        const VdfContext &context) const {
        return VdfRequiredInputsPredicate::NoReads(*this);
    }
 
    VDF_API
    virtual void Compute(const VdfContext &context) const;
 
    VDF_API
    const VdfSchedule &GetSchedule(const VdfSchedule *requestingSched) const;
 
private:
   
    // Only a network is allowed to delete nodes.
    VDF_API
    virtual ~VdfSpeculationNode();
    
    const VdfExecutorInterface &_GetContextExecutor(
        const VdfContext &context) const {
        return context._GetExecutor(); 
    }
 
    VdfRequest _GetInputRequest(const VdfSchedule &requestingSched) const;
 
    const VdfSchedule *_GetSchedule(const VdfRequest &request) const;
 
    virtual VdfMask _ComputeOutputDependencyMask(
        const VdfConnection &inputConnection,
        const VdfMask &inputDependencyMask,
        const VdfOutput &output) const;
 
    virtual VdfMask::Bits _ComputeInputDependencyMask(
        const VdfMaskedOutput &maskedOutput,
        const VdfConnection &inputConnection) const;
 
private:
 
    // A hash functor for VdfRequest.
    struct _HashRequest {
        bool equal(const VdfRequest &lhs, const VdfRequest &rhs) const {
            return lhs == rhs;
        }
 
        size_t hash(const VdfRequest &request) const {
            return VdfRequest::Hash()(request);
        }
    };
 
    // This is a schedule map that holds the schedules that we will use to
    // compute the node.  Invalidation is automatic from the 
    // network for which they are scheduled.
    using _ScheduleMap = tbb::concurrent_hash_map<
        VdfRequest, std::unique_ptr<VdfSchedule>, _HashRequest>;
    mutable _ScheduleMap _scheduleMap;
};
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif