scheduleTasks.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_SCHEDULE_TASKS_H
#define PXR_EXEC_VDF_SCHEDULE_TASKS_H


#include "pxr/pxr.h"

#include "pxr/exec/vdf/mask.h"

#include "pxr/base/tf/diagnostic.h"

PXR_NAMESPACE_OPEN_SCOPE

class VdfOutput;

typedef uint32_t VdfScheduleTaskId;

typedef uint32_t VdfScheduleTaskIndex;

typedef uint32_t VdfScheduleTaskNum;

static const uint32_t VdfScheduleTaskInvalid = uint32_t(-1);

inline bool VdfScheduleTaskIsInvalid(uint32_t task) {
    return task == VdfScheduleTaskInvalid;
}

struct VdfScheduleNodeTasks {
    VdfScheduleTaskId taskId;
    VdfScheduleTaskNum taskNum;
};

struct VdfScheduleComputeTaskFlags {
    bool isAffective : 1;   // Is this compute task affective?
    bool hasKeep : 1;       // Does this compute task keep any data?
};

struct VdfScheduleComputeTask {
    // The index into the VdfScheduleNodeInvocation array. This is an invalid
    // index for nodes with only one compute task.
    VdfScheduleTaskIndex invocationIndex;

    // The corresponding inputs task. This is an invalid task index for nodes
    // with only one compute task, and without prereqs and reads, which could
    // be run in parallel with read/writes.
    VdfScheduleTaskIndex inputsTaskIndex;

    // The corresponding node preparation task. Every scheduled node has at
    // most one of these. The task is shared amongst all invocations of that
    // node. An invalid index denotes that node preparation need not be
    // synchronized.
    VdfScheduleTaskIndex prepTaskIndex;

    // Index into the input dependencies array. The first required input
    // dependency, i.e. read/write or read not dependent on prereqs.
    VdfScheduleTaskIndex requiredsIndex;

    // The number of required input dependencies.
    VdfScheduleTaskNum requiredsNum;

    // Additional bit flags.
    VdfScheduleComputeTaskFlags flags;
};

struct VdfScheduleNodeInvocation {
    VdfMask requestMask;
    VdfMask affectsMask;
    VdfMask keepMask;
};

struct VdfScheduleInputsTask {
    VdfScheduleTaskIndex inputDepIndex;
    VdfScheduleTaskNum prereqsNum;
    VdfScheduleTaskNum optionalsNum;
};

typedef uint32_t VdfScheduleInputDependencyUniqueIndex;

struct VdfScheduleInputDependency {
    // A unique index for the output and mask combination of this dependency.
    VdfScheduleInputDependencyUniqueIndex uniqueIndex;

    // The requested output at the source end of the input dependency.
    const VdfOutput &output;

    // The requested mask at the source end of the input dependency.
    VdfMask mask; 

    // The compute task id of the first task to be invoked to fulfill this
    // input dependency. Note, this can be a compute task id, or a keep task
    // index. If this is a keep task index, computeTaskNum shall be set to 0.
    VdfScheduleTaskId computeOrKeepTaskId;

    // The number of compute task ids to be invoked to fulfill this input
    // dependency. If this is 0, the input dependency is for a keep task.
    VdfScheduleTaskNum computeTaskNum;
};

PXR_NAMESPACE_CLOSE_SCOPE

#endif