sparseOutputTraverser.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_SPARSE_OUTPUT_TRAVERSER_H
#define PXR_EXEC_VDF_SPARSE_OUTPUT_TRAVERSER_H
 
 
#include "pxr/pxr.h"
 
#include "pxr/exec/vdf/api.h"
#include "pxr/exec/vdf/maskedOutputVector.h"
#include "pxr/exec/vdf/types.h"
 
#include "pxr/base/tf/hashmap.h"
 
#include <queue>
#include <vector>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class VdfInput;
class VdfMask;
class VdfOutput;
 
class VdfSparseOutputTraverser
{
public:
    static const int MaxRequestsBeforeEviction = 10;
 
    VDF_API
    VdfSparseOutputTraverser(bool enableCaching = true);
 
    typedef std::function<
        bool (const VdfOutput &, const VdfMask &, const VdfInput *) >
        OutputCallback;
 
 
 
    VDF_API
    static void Traverse(
        const VdfMaskedOutputVector &outputs,
        const OutputCallback        &outputCallback,
        const VdfNodeCallback       &nodeCallback);
 
    VDF_API
    void TraverseWithCaching(
        const VdfMaskedOutputVector &outputs,
        const OutputCallback        &outputCallback,
        const VdfNodeCallback       &nodeCallback);
 
 
 
    VDF_API
    void InvalidateAll();
 
private:
    
    struct _CacheEntry;
 
    // A cache line stored in the traversal cache map
    struct _Cache
    {
        // The indices to all the root cache entries, representing the root
        // nodes in the cached request
        std::vector<int> rootIndices;
 
        // A vector of cache entries
        typedef std::vector<_CacheEntry> CacheEntries;
        CacheEntries cacheEntries;
    };
 
    // Returns a new or existing cache entry keyed off of the sorted request.
    // This method will also enforce the eviction policy.
    _Cache* _GetOrCreateCacheEntry(const VdfMaskedOutputVector &sortedOutputs);
 
    class _TraversalHelper;
 
private:
 
    // Flag to switch caching on and off (defaults to on).
    bool _enableCaching;
 
    // A map from masked outputs to _Cache objects. 
    using _TraversalCache =
        TfHashMap<VdfMaskedOutputVector, _Cache, VdfMaskedOutputVector_Hash>;
 
    // Cache used to speed up repeated traversals.
    _TraversalCache _cache;
 
    // The cache history is defined as a queue adaptor with an underlaying deque
    using _CacheHistory = std::queue<_TraversalCache::iterator>;
 
    // Maintain a history of added cache entries to allow for eviction
    // of oldest cache entries
    _CacheHistory _cacheHistory;
 
};
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif