Adds the logic that performs authored value invalidation, but does not yet exercise this logic.

(Internal change: 2365433)

Author: FlorianZ

pxr/exec/ef/leafNode.h

@@ -52,6 +52,14 @@ class EF_API_TYPE EfLeafNode final : public VdfNode
         return input ? &(*input)[0].GetSourceOutput() : nullptr;
     }
 
+    /// Returns the single masked output the leaf node sources its value from.
+    /// Returns an invalid masked output if the leaf node is not connected.
+    ///
+    static VdfMaskedOutput GetSourceMaskedOutput(const VdfNode &node) {
+        const VdfInput *const input = node.GetInputsIterator().begin()->second;
+        return input ? (*input)[0].GetSourceMaskedOutput() : VdfMaskedOutput();
+    }
+
     EF_API
     EfLeafNode(VdfNetwork *network, TfType inputType);
 

pxr/exec/esf/attribute.h

@@ -49,8 +49,7 @@ class ESF_API_TYPE EsfAttributeInterface : public EsfPropertyInterface
     ///
     /// \see UsdAttribute::Get
     ///
-    bool Get(VtValue *value, UsdTimeCode time) const
-    {
+    bool Get(VtValue *value, UsdTimeCode time) const {
         return _Get(value, time);
     }
 

pxr/exec/exec/CMakeLists.txt

@@ -20,6 +20,7 @@ pxr_library(exec
         api.h
         providerResolution.h
         registerSchema.h
+        request.h
         types.h
 
     PUBLIC_CLASSES

pxr/exec/exec/attributeInputNode.h

@@ -38,11 +38,18 @@ class Exec_AttributeInputNode final : public VdfNode
 
     ~Exec_AttributeInputNode() override;
 
+    /// Returns the scene path to the attribute that the input value is sourced
+    /// from.
+    /// 
+    SdfPath GetAttributePath() const {
+        return _attribute->GetPath(nullptr);
+    }
+
     void Compute(VdfContext const& ctx) const override;
 
 private:
-    // TODO: Long-term, we will need some kind of handle to the attribute that is
-    // stable across namespace edits.
+    // TODO: Long-term, we will need some kind of handle to the attribute that
+    // is stable across namespace edits.
     const EsfAttribute _attribute;
 };
 

pxr/exec/exec/cacheView.cpp

@@ -40,6 +40,8 @@ Exec_CacheView::Extract(int idx, VtValue *result) const
         return false;
     }
 
+    // TODO: VdfVector -> VtValue extraction
+
     TF_CODING_ERROR("Extraction is not yet implemented");
     return false;
 }

pxr/exec/exec/cacheView.h

@@ -40,7 +40,7 @@ class Exec_CacheView
     bool Extract(int idx, VtValue *result) const;
 
 private:
-    friend class ExecSystem;
+    friend class Exec_RequestImpl;
     Exec_CacheView(
         const VdfExecutorInterface *executor,
         TfSpan<const VdfMaskedOutput> outputs)

pxr/exec/exec/program.cpp

@@ -8,11 +8,14 @@
 
 #include "pxr/base/tf/span.h"
 #include "pxr/base/tf/token.h"
+#include "pxr/base/trace/trace.h"
 #include "pxr/exec/ef/timeInputNode.h"
 #include "pxr/exec/ef/timeInterval.h"
+#include "pxr/exec/vdf/executorInterface.h"
 #include "pxr/exec/vdf/grapher.h"
 #include "pxr/exec/vdf/maskedOutput.h"
 #include "pxr/exec/vdf/node.h"
+#include "pxr/exec/vdf/typedVector.h"
 #include "pxr/usd/sdf/path.h"
 
 PXR_NAMESPACE_OPEN_SCOPE
@@ -79,12 +82,140 @@ Exec_Program::Connect(
         inputNode->GetId(), inputName, journal);
 }
 
-void
+std::tuple<const std::vector<const VdfNode *> &, TfBits, EfTimeInterval>
 Exec_Program::InvalidateAuthoredValues(
     TfSpan<ExecInvalidAuthoredValue> invalidProperties)
 {
-    // TODO: Leaf node and request invalidation, as well as queueing up main
-    // executor invalidation. 
+    TRACE_FUNCTION();
+
+    const size_t numInvalidProperties = invalidProperties.size();
+
+    VdfMaskedOutputVector leafInvalidationRequest;
+    leafInvalidationRequest.reserve(numInvalidProperties);
+    TfBits compiledProperties(numInvalidProperties);
+    _uninitializedInputNodes.reserve(numInvalidProperties);
+    EfTimeInterval totalInvalidInterval;
+
+    for (size_t i = 0; i < numInvalidProperties; ++i) {
+        const auto &[path, interval] = invalidProperties[i];
+        const auto it = _inputNodes.find(path);
+
+        // Not every invalid property is also an input to the exec network.
+        // If any of these properties have been included in an exec request,
+        // clients still expect to receive invalidation notices, though.
+        // However, we can skip including this property in the search for
+        // dependent leaf nodes in that case.
+        const bool isCompiled = it != _inputNodes.end();
+        if (!isCompiled) {
+            continue;
+        }
+
+        // Indicate this property was compiled.
+        compiledProperties.Set(i);
+
+        // Get the input node from the network.
+        const VdfId nodeId = it->second;
+        VdfNode *const node = _network.GetNodeById(nodeId);
+
+        // We expect uncompiled input nodes to have been removed from the
+        // _inputNodes array by now.
+        if (!TF_VERIFY(node)) {
+            continue;
+        }
+
+        // If this is an input node to the exec network, we need to make sure
+        // that it is re-initialized before the next round of evaluation.
+        _uninitializedInputNodes.push_back(nodeId);
+
+        // Queue the input node's output(s) for leaf node invalidation.
+        leafInvalidationRequest.emplace_back(
+            node->GetOutput(), VdfMask::AllOnes(1));
+
+        // Accumulate the invalid time interval.
+        totalInvalidInterval |= interval;
+    }
+
+    // Find all the leaf nodes reachable from the input nodes.
+    // We won't ask the leaf node cache to incur the cost of performing
+    // incremental updates on the resulting cached traversal, because it is not
+    // guaranteed that we will repeatedly see the exact same authored value
+    // invalidation across rounds of structural change processing (in contrast
+    // to time invalidation).
+    const std::vector<const VdfNode *> &leafNodes = _leafNodeCache.FindNodes(
+        leafInvalidationRequest, /* updateIncrementally = */ false);
+
+    // TODO: Perform page cache invalidation.
+
+    return {leafNodes, compiledProperties, totalInvalidInterval};
+}
+
+void
+Exec_Program::InitializeTime(
+    VdfExecutorInterface *const executor,
+    const EfTime &newTime) const
+{
+    // Retrieve the old time from the executor data manager.
+    const VdfVector *const oldTimeVector = executor->GetOutputValue(
+        *_timeInputNode->GetOutput(), VdfMask::AllOnes(1));
+
+    // If there isn't already a time value stored in the executor data manager,
+    // perform first time initialization and return.
+    if (!oldTimeVector) {
+        executor->SetOutputValue(
+            *_timeInputNode->GetOutput(),
+            VdfTypedVector<EfTime>(newTime),
+            VdfMask::AllOnes(1));
+        return;
+    }
+
+    // Get the old time value from the vector. If there is not change in time,
+    // we can return without performing invalidation.
+    const EfTime oldTime = oldTimeVector->GetReadAccessor<EfTime>()[0];
+    if (oldTime == newTime) {
+        return;
+    }
+
+    TRACE_FUNCTION();
+
+    // TODO: Collect time dependent properties and perform executor invalidation
+    // after time changes.
+
+    // Set the new time value on the executor.
+    executor->SetOutputValue(
+        *_timeInputNode->GetOutput(),
+        VdfTypedVector<EfTime>(newTime),
+        VdfMask::AllOnes(1));
+}
+
+VdfMaskedOutputVector
+Exec_Program::InitializeInputNodes()
+{
+    if (_uninitializedInputNodes.empty()) {
+        return {};
+    }
+
+    TRACE_FUNCTION();
+
+    // Collect the invalid outputs for all invalid input nodes accumulated
+    // through previous rounds of authored value invalidation.
+    VdfMaskedOutputVector invalidationRequest;
+    invalidationRequest.reserve(_uninitializedInputNodes.size());
+    for (const VdfId nodeId : _uninitializedInputNodes) {
+        VdfNode *const node = _network.GetNodeById(nodeId);
+
+        // Some nodes may have been uncompiled since they were marked as being
+        // uninitialized. It's okay to simply skip these nodes.
+        if (!node) {
+            continue;
+        }
+
+        invalidationRequest.emplace_back(
+            node->GetOutput(), VdfMask::AllOnes(1));
+    }
+
+    _uninitializedInputNodes.clear();
+
+    return invalidationRequest;
 }
 
 void
@@ -99,4 +230,21 @@ Exec_Program::_AddNode(const EsfJournal &journal, const VdfNode *node)
     _uncompilationTable.AddRulesForNode(node->GetId(), journal);
 }
 
+void
+Exec_Program::_RegisterInputNode(const Exec_AttributeInputNode *const inputNode)
+{
+    const auto [it, emplaced] = _inputNodes.emplace(
+        inputNode->GetAttributePath(), inputNode->GetId());
+    TF_VERIFY(emplaced);
+}
+
+void
+Exec_Program::_UnregisterInputNode(
+    const Exec_AttributeInputNode *const inputNode)
+{
+    const SdfPath attributePath = inputNode->GetAttributePath();
+    const size_t numErased = _inputNodes.unsafe_erase(attributePath);
+    TF_VERIFY(numErased);
+}
+
 PXR_NAMESPACE_CLOSE_SCOPE

pxr/exec/exec/program.h

@@ -9,22 +9,36 @@
 
 #include "pxr/pxr.h"
 
+#include "pxr/exec/exec/attributeInputNode.h"
 #include "pxr/exec/exec/compiledOutputCache.h"
 #include "pxr/exec/exec/types.h"
 #include "pxr/exec/exec/uncompilationTable.h"
 
+#include "pxr/base/tf/bits.h"
 #include "pxr/exec/ef/leafNodeCache.h"
+#include "pxr/exec/ef/time.h"
 #include "pxr/exec/vdf/maskedOutput.h"
+#include "pxr/exec/vdf/maskedOutputVector.h"
 #include "pxr/exec/vdf/network.h"
+#include "pxr/exec/vdf/types.h"
+#include "pxr/usd/sdf/path.h"
+
+#include <tbb/concurrent_unordered_map.h>
 
 #include <memory>
+#include <tuple>
 #include <type_traits>
+#include <vector>
 
 PXR_NAMESPACE_OPEN_SCOPE
 
+class EfTime;
 class EfTimeInputNode;
+class EfTimeInterval;
 class EsfJournal;
+class TfBits;
 template <typename> class TfSpan;
+class VdfExecutorInterface;
 class VdfNode;
 
 /// Owns a VdfNetwork and related data structures to access and modify the
@@ -126,23 +140,61 @@ class Exec_Program
     }
 
     /// Notifies the program of authored value invalidation.
-    void InvalidateAuthoredValues(
+    std::tuple<const std::vector<const VdfNode *> &, TfBits, EfTimeInterval>
+    InvalidateAuthoredValues(
         TfSpan<ExecInvalidAuthoredValue> invalidProperties);
 
+    /// Initializes time in the network.
+    void InitializeTime(
+        VdfExecutorInterface *executor,
+        const EfTime &newTime) const;
+
+    /// Initializes all invalid input nodes in the network, and returns a vector
+    /// of invalid input node outputs.
+    /// 
+    VdfMaskedOutputVector InitializeInputNodes();
+
     /// Writes the compiled network to a file at \p filename.
     void GraphNetwork(const char *filename) const;
 
 private:
-    // Updates data strucutres for a newly-added node.
+    // Updates data structures for a newly-added node.
     void _AddNode(const EsfJournal &journal, const VdfNode *node);
 
-    class _EditMonitor;
+    // Registers an input node for authored value initialization.
+    void _RegisterInputNode(const Exec_AttributeInputNode *inputNode);
+
+    // Unregisters an input node from authored value initialization.
+    void _UnregisterInputNode(const Exec_AttributeInputNode *inputNode);
 
+private:
+    // The compiled data flow network.
     VdfNetwork _network;
+
+    // Every network always has a compiled time input node.
     EfTimeInputNode *const _timeInputNode;
+
+    // A cache of compiled outputs keys and corresponding data flow outputs.
     Exec_CompiledOutputCache _compiledOutputCache;
+
+    // Maps scene paths to data flow network that must be uncompiled in response
+    // to edits to those scene paths.
     Exec_UncompilationTable _uncompilationTable;
+
+    // Collection of compiled leaf nodes.
     EfLeafNodeCache _leafNodeCache;
+
+    // Collection of compiled input nodes.
+    // TODO: We will need to update this map in response to namespace edits,
+    // once they are supported.
+    tbb::concurrent_unordered_map<SdfPath, VdfId, SdfPath::Hash> _inputNodes;
+
+    // Input nodes currently queued for initialization.
+    std::vector<VdfId> _uninitializedInputNodes;
+
+    // On behalf of the program intercepts and responds to fine-grained network
+    // edits.
+    class _EditMonitor;
     std::unique_ptr<_EditMonitor> _editMonitor;
 };
 
@@ -162,6 +214,12 @@ NodeType *Exec_Program::CreateNode(
     NodeType *const node = new NodeType(
         &_network, std::forward<NodeCtorArgs>(nodeCtorArgs)...);
     _AddNode(journal, node);
+
+    // Input nodes are tracked for authored value initialization.
+    if constexpr (std::is_same_v<Exec_AttributeInputNode, NodeType>) {
+        _RegisterInputNode(node);
+    }
+
     return node;
 }