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