dataManagerVector.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_DATA_MANAGER_VECTOR_H
#define PXR_EXEC_VDF_DATA_MANAGER_VECTOR_H
 
 
#include "pxr/pxr.h"
 
#include "pxr/exec/vdf/api.h"
#include "pxr/exec/vdf/executorDataManager.h"
#include "pxr/exec/vdf/executorDataVector.h"
#include "pxr/exec/vdf/types.h"
 
PXR_NAMESPACE_OPEN_SCOPE
 
enum class VdfDataManagerDeallocationMode
{
    Background = 0,
 
    Immediate
};
 
 
template<VdfDataManagerDeallocationMode DeallocationMode>
class VdfDataManagerVector;
class VdfExecutorBufferData;
class VdfExecutorInvalidationData;
class VdfNetwork;
class VdfOutput;
class VdfSMBLData;
 
template<VdfDataManagerDeallocationMode Mode>
struct Vdf_ExecutorDataManagerTraits< VdfDataManagerVector<Mode> > {
 
    typedef Vdf_ExecutorDataVector::DataHandle DataHandle;
};
 
 
 
// Allocates an executor data vector for the given \p network.
VDF_API
Vdf_ExecutorDataVector *
Vdf_DataManagerVectorAllocate(const VdfNetwork &network);
 
// Deallocates the executor data vector \p data that was alloacted with
// Vdf_DataManagerVectorAllocate, and does so immediately.
VDF_API
void
Vdf_DataManagerVectorDeallocateNow(Vdf_ExecutorDataVector *data);
 
// Queues up deallocation of the executor data vector \p data that was 
// alloacted with Vdf_DataManagerVectorAllocate.  The actually memory
// will be deallocated at an unspecified time in the future.
VDF_API
void 
Vdf_DataManagerVectorDeallocateLater(Vdf_ExecutorDataVector *data);
 
 
template<VdfDataManagerDeallocationMode DeallocationMode>
class VdfDataManagerVector : 
    public VdfExecutorDataManager<VdfDataManagerVector<DeallocationMode> >
{
public:
 
    typedef
        VdfExecutorDataManager<VdfDataManagerVector>
        Base;
 
    typedef
        typename Vdf_ExecutorDataManagerTraits<
            VdfDataManagerVector>::DataHandle
        DataHandle;
 
    VdfDataManagerVector() : _data(nullptr) { }
 
    ~VdfDataManagerVector();
 
    void Resize(const VdfNetwork &network);
 
    bool IsValidDataHandle(const DataHandle handle) const {
        return handle != Vdf_ExecutorDataVector::InvalidHandle;
    }
 
    DataHandle GetOrCreateDataHandle(const VdfId outputId) const {
        return _data->GetOrCreateDataHandle(outputId);
    }
 
    DataHandle GetDataHandle(const VdfId outputId) const {
        return _data
            ? _data->GetDataHandle(outputId)
            : Vdf_ExecutorDataVector::InvalidHandle;
    }
 
    VdfExecutorBufferData * GetBufferData(const DataHandle handle) const {
        return _data->GetBufferData(handle);
    }
 
    VdfExecutorInvalidationData * GetInvalidationData(
        const DataHandle handle) const {
        return _data->GetInvalidationData(handle);
    }
 
    using Base::GetInvalidationTimestamp;
 
    VdfInvalidationTimestamp GetInvalidationTimestamp(
        const DataHandle handle) const {
        return _data->GetInvalidationTimestamp(handle);
    }
 
    void SetInvalidationTimestamp(
        const DataHandle handle,
        VdfInvalidationTimestamp timestamp) {
        _data->SetInvalidationTimestamp(handle, timestamp);
    }
 
    VdfSMBLData * GetSMBLData(const DataHandle handle) const {
        return _data->GetSMBLData(handle);
    }
 
    VdfSMBLData * GetOrCreateSMBLData(const DataHandle handle) const {
        return _data->GetOrCreateSMBLData(handle);
    }
 
    bool IsTouched(const DataHandle handle) const {
        return _data->IsTouched(handle);
    }
 
    void Touch(const DataHandle handle) const {
        _data->Touch(handle);
    }
 
    bool Untouch(const DataHandle handle) {
        return _data->Untouch(handle);
    }
 
    void ClearDataForOutput(const VdfId outputId);
 
    void Clear();
 
    bool IsEmpty() const {
        return !_data || _data->GetNumData() == 0;
    }
 
 
private:
 
    // The Vdf_ExecutorDataVector instance that holds the data.
    mutable Vdf_ExecutorDataVector *_data;
 
};
 
 
template<VdfDataManagerDeallocationMode DeallocationMode>
VdfDataManagerVector<DeallocationMode>::~VdfDataManagerVector()
{
    if (DeallocationMode == VdfDataManagerDeallocationMode::Immediate) {
        Vdf_DataManagerVectorDeallocateNow(_data);
    } else {
        Vdf_DataManagerVectorDeallocateLater(_data);
    }
}
 
template<VdfDataManagerDeallocationMode DeallocationMode>
void
VdfDataManagerVector<DeallocationMode>::Resize(const VdfNetwork &network)
{
    // Allocate a new Vdf_ExecutorDataVector if necessary. 
    if (!_data) {
        _data = Vdf_DataManagerVectorAllocate(network);
    }
 
    // Otherwise, make sure to resize our current instance.
    else {
        _data->Resize(network);
    }
}
 
template<VdfDataManagerDeallocationMode DeallocationMode>
void
VdfDataManagerVector<DeallocationMode>::ClearDataForOutput(
    const VdfId outputId)
{
    // Clear the data associated with the given output (if it exists).
    if (_data) {
        const DataHandle dataHandle = _data->GetDataHandle(outputId);
        if (IsValidDataHandle(dataHandle)) {
            _data->Reset(dataHandle, outputId);
        }
    }
}
 
template<VdfDataManagerDeallocationMode DeallocationMode>
void
VdfDataManagerVector<DeallocationMode>::Clear()
{
    // Clear all data.
    if (_data) {
        _data->Clear();
    }
}
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif