executorDataVector.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_EXECUTOR_DATA_VECTOR_H
#define PXR_EXEC_VDF_EXECUTOR_DATA_VECTOR_H
 
 
#include "pxr/pxr.h"
 
#include "pxr/exec/vdf/api.h"
#include "pxr/exec/vdf/executorBufferData.h"
#include "pxr/exec/vdf/executorInvalidationData.h"
#include "pxr/exec/vdf/output.h"
#include "pxr/exec/vdf/smblData.h"
#include "pxr/exec/vdf/types.h"
 
#include <tbb/concurrent_vector.h>
 
#include <memory>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class VdfNetwork;
 
class Vdf_ExecutorDataVector
{
public:
 
    typedef size_t DataHandle;
 
    static const size_t InvalidHandle = size_t(-1);
 
    VDF_API
    ~Vdf_ExecutorDataVector();
 
    VDF_API
    void Resize(const VdfNetwork &network);
 
    inline DataHandle GetOrCreateDataHandle(const VdfId outputId);
 
    inline DataHandle GetDataHandle(const VdfId outputId) const;
 
    VdfExecutorBufferData * GetBufferData(const DataHandle handle) {
        return &_bufferData[handle];
    }
 
    VdfExecutorInvalidationData * GetInvalidationData(const DataHandle handle) {
        return &_invalidationData[handle];
    }
 
    VdfInvalidationTimestamp GetInvalidationTimestamp(
        const DataHandle handle) const {
        return _outputData[handle].invalidationTimestamp;
    }
 
    void SetInvalidationTimestamp(
        const DataHandle &handle,
        VdfInvalidationTimestamp ts) {
        _outputData[handle].invalidationTimestamp = ts;
    }
 
    VdfSMBLData * GetSMBLData(const DataHandle handle) const {
        return _smblData[handle].get();
    }
 
    VdfSMBLData * GetOrCreateSMBLData(const DataHandle handle) {
        if (!_smblData[handle]) {
            _smblData[handle].reset(new VdfSMBLData());
        }
        return _smblData[handle].get();
    }
 
    bool IsTouched(const DataHandle handle) {
        return _outputData[handle].touched;
    }
 
    void Touch(const DataHandle handle) {   
        _outputData[handle].touched = true;
    }
 
    bool Untouch(const DataHandle handle) {
        const bool wasTouched = _outputData[handle].touched;
        _outputData[handle].touched = false;
        return wasTouched;
    }
 
    size_t GetSize() const {
        return _locations.size();
    }
 
    size_t GetNumData() const {
        return _bufferData.size();
    }
 
    inline void Reset(const DataHandle handle, const VdfId outputId);
 
    VDF_API
    void Clear();
 
private:
 
    // The auxiliary output data stored for each output in the vector.
    struct _OutputData {
        _OutputData(const VdfId oid) :
            outputId(oid),
            invalidationTimestamp(
                VdfExecutorInvalidationData::InitialInvalidationTimestamp),
            touched(false)
        {}
 
        void Reset(const VdfId oid) {
            outputId = oid;
            invalidationTimestamp =
                VdfExecutorInvalidationData::InitialInvalidationTimestamp;
            touched = false;
        }
 
        VdfId outputId;
        VdfInvalidationTimestamp invalidationTimestamp;
        bool touched;
    };
 
    // Type of each segment in the locations array. An array of integers.
    using _LocationsSegment = uint32_t *;
 
    // Create a new segment at the provided index out of line, and return a
    // pointer to the new segment.
    VDF_API
    _LocationsSegment _CreateSegment(size_t segmentIndex);
 
    // Pushes a new data entry into the internal vectors for the output with
    // the given outputId.
    inline void _CreateData(const VdfId outputId);
 
    // Reserve this many executor data entries
    constexpr static size_t _InitialExecutorDataNum = 1000;
 
    // The size of a segment in the segmented locations array. Must be a power
    // of two.
    constexpr static size_t _SegmentSize = 4096;
 
    // The locations array, indexing the data vector.
    std::vector<_LocationsSegment> _locations;
 
    // The data vector. Note we use a tbb::concurrent_vector here not for its
    // thread-safe properties, but for the fact that it allocates chunks of
    // contiguous memory, and does not copy/move any existing elements when
    // the container grows.
    tbb::concurrent_vector<_OutputData> _outputData;
    tbb::concurrent_vector<VdfExecutorBufferData> _bufferData;
    tbb::concurrent_vector<VdfExecutorInvalidationData> _invalidationData;
    tbb::concurrent_vector<std::unique_ptr<VdfSMBLData>> _smblData;
 
};
 
 
Vdf_ExecutorDataVector::DataHandle
Vdf_ExecutorDataVector::GetOrCreateDataHandle(const VdfId outputId)
{
    // Get the output index.
    const VdfIndex outputIndex = VdfOutput::GetIndexFromId(outputId);
 
    // Compute the index of the segment.
    const size_t segmentIndex = outputIndex / _SegmentSize;
    TF_DEV_AXIOM(segmentIndex < _locations.size());
 
    // Retrieve the corresponding segment, or create a new one of necessary.
    _LocationsSegment segment = _locations[segmentIndex];
    if (!segment) {
        segment = _CreateSegment(segmentIndex);
    }
 
    // Using the segment offset, look up the location in the segment.
    const size_t segmentOffset = outputIndex & (_SegmentSize - 1);
    uint32_t * const location = &segment[segmentOffset];
 
    // The location may be uninitialized, so let's do a bounds check against
    // the data vector. We further have to check whether the index at the
    // proposed location in the data vector points back to the same output.
    // If either of this is false, we will insert a new entry into the data
    // vector and update the location.
    const size_t numData = GetNumData();
    if (*location >= numData ||
        outputIndex != VdfOutput::GetIndexFromId(
            _outputData[*location].outputId)) {
        *location = numData;
        _CreateData(outputId);
    }
 
    // If the location points to the right place in the data vector, we must
    // also verify the output version. Note, that we do not have to extract
    // the version from the id. At this point, the entire id better match!
    // If not, the version has changed an the output data must be reset.
    else if (outputId != _outputData[*location].outputId) {
        Reset(*location, outputId);
    }
 
    // Return the newly inserted or existing data entry.
    return *location;
}
 
Vdf_ExecutorDataVector::DataHandle
Vdf_ExecutorDataVector::GetDataHandle(const VdfId outputId) const
{
    // Get the output index.
    const VdfIndex outputIndex = VdfOutput::GetIndexFromId(outputId);
 
    // Compute the index to the segment.
    const size_t segmentIndex = outputIndex / _SegmentSize;
 
    // If the segment index is out of bounds or the segment has not been
    // allocated, we can bail out right away.
    if (segmentIndex >= _locations.size() || !_locations[segmentIndex]) {
        return InvalidHandle;
    }
 
    // If the location points to a valid entry in the data vector, and the
    // data at that index matches the output id, we can return the data.
    // Otherwise, the location may either be garbage, or the output version
    // may have changed.
    const size_t segmentOffset = outputIndex & (_SegmentSize - 1);
    const uint32_t location = _locations[segmentIndex][segmentOffset];
    return
        location < GetNumData() && outputId == _outputData[location].outputId
            ? location
            : InvalidHandle;
}
 
void
Vdf_ExecutorDataVector::Reset(const DataHandle handle, const VdfId outputId)
{
    _outputData[handle].Reset(outputId);
    _bufferData[handle].Reset();
    _invalidationData[handle].Reset();
    _smblData[handle].reset();
}
 
void
Vdf_ExecutorDataVector::_CreateData(const VdfId outputId)
{
    _outputData.emplace_back(outputId);
    _bufferData.emplace_back();
    _invalidationData.emplace_back();
    _smblData.emplace_back();
}
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif