scheduler.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_SCHEDULER_H
#define PXR_EXEC_VDF_SCHEDULER_H
 
 
#include "pxr/pxr.h"
 
#include "pxr/exec/vdf/api.h"
#include "pxr/exec/vdf/poolChainIndex.h"
 
#include "pxr/base/tf/hashmap.h"
 
#include <atomic>
#include <utility>
#include <vector>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class VdfMaskedOutput;
using VdfMaskedOutputVector = std::vector<VdfMaskedOutput>;
class VdfNetwork;
class VdfNode;
class VdfRequest;
class VdfSchedule;
class VdfScheduleNode;
class VdfScheduleOutput;
 
class VdfScheduler 
{
public:
    // Vector of priorities for pool outputs.
    typedef std::vector<
        std::pair<VdfPoolChainIndex, const VdfOutput *>
    > PoolPriorityVector;
 
    using NodeToRequestMap =
        TfHashMap<const VdfNode *, VdfMaskedOutputVector, TfHash>;
 
    VDF_API
    VdfScheduler(const std::atomic_bool *interruptionFlag);
 
    VDF_API
    static void Schedule(const VdfRequest &request, VdfSchedule *schedule,
        bool topologicallySort);
 
    VDF_API
    bool CreateSchedule(const VdfRequest &request, VdfSchedule *schedule,
        bool topologicallySort);
 
    VDF_API
    static bool UpdateAffectsMaskForOutput(
        VdfSchedule *schedule,
        const VdfOutput &output);
 
protected:
    bool _HasBeenInterrupted() const {
        return _interruptionFlag &&
            _interruptionFlag->load(std::memory_order_relaxed);
    }
 
    VDF_API
    static void _SetScheduleValid(
        VdfSchedule *schedule, 
        const VdfNetwork *network);
 
    VDF_API
    bool _InitializeRequestMasks(
        const VdfRequest &request,
        VdfSchedule *schedule,
        PoolPriorityVector *poolOutputs);
 
    VDF_API
    static void _MarkSmallSchedule(VdfSchedule *schedule);
 
    VDF_API
    bool _ScheduleBufferPasses(
        const VdfRequest &request,
        VdfSchedule *schedule);
 
    VDF_API
    bool _ScheduleForPassThroughs(
        const VdfRequest &request,
        VdfSchedule *schedule,
        const PoolPriorityVector &sortedPoolOutputs);
 
    VDF_API
    void _GenerateTasks(
        VdfSchedule *schedule,
        const PoolPriorityVector &sortedPoolOutputs);
 
    VDF_API
    bool _ScheduleTaskGraph(
        VdfSchedule *schedule,
        const PoolPriorityVector &sortedPoolOutputs);
 
    VDF_API
    static void _ComputeLockMasks(
        const VdfRequest &request, 
        VdfSchedule *schedule,
        const PoolPriorityVector &sortedPoolOutputs);
 
    VDF_API
    bool _ApplyAffectsMasks(VdfSchedule *schedule);
 
    VDF_API
    static bool _ApplyAffectsMasksForNode(VdfScheduleNode *node);
 
    VDF_API
    static void _UpdateAffectsMaskForInvocation(
        VdfSchedule *schedule,
        VdfScheduleNode *node);
 
    VDF_API
    static bool _UpdateAffectsMasksForNode(
        VdfSchedule *schedule,
        VdfScheduleNode *node);
 
    VDF_API
    static void _UpdateLockMaskForNode(
        VdfSchedule *schedule,
        VdfScheduleNode *node);
 
private:
 
    // Used to optionally support scheduling interruption.
    const std::atomic_bool *_interruptionFlag = nullptr;
};
 
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif