dataManagerHashTable.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_HASH_TABLE_H
#define PXR_EXEC_VDF_DATA_MANAGER_HASH_TABLE_H
 
 
#include "pxr/pxr.h"
 
#include "pxr/exec/vdf/api.h"
#include "pxr/exec/vdf/executorBufferData.h"
#include "pxr/exec/vdf/executorDataManager.h"
#include "pxr/exec/vdf/executorInvalidationData.h"
#include "pxr/exec/vdf/smblData.h"
#include "pxr/exec/vdf/types.h"
 
#include "pxr/base/tf/hash.h"
#include "pxr/base/tf/stl.h"
 
#include <memory>
#include <unordered_map>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class VdfDataManagerHashTable;
class VdfOutput;
class VdfNetwork;
 
template<>
struct Vdf_ExecutorDataManagerTraits<VdfDataManagerHashTable> {
 
    struct OutputData {
        OutputData() :
            invalidationTimestamp(
                VdfExecutorInvalidationData::InitialInvalidationTimestamp),
            touched(false)
        {}
 
        VdfExecutorBufferData bufferData;
        VdfExecutorInvalidationData invalidationData;
        VdfInvalidationTimestamp invalidationTimestamp;
        std::unique_ptr<VdfSMBLData> smblData;
        bool touched;
    };
 
    typedef OutputData * DataHandle;
 
};
 
class VdfDataManagerHashTable : 
    public VdfExecutorDataManager<VdfDataManagerHashTable>
{
 
    // The output data stored at each entry.
    typedef
        typename Vdf_ExecutorDataManagerTraits<
            VdfDataManagerHashTable>::OutputData
        _OutputData;
 
    // Data type for map from outputs to their executor data.
    using _DataMap = std::unordered_map<VdfId, _OutputData, TfHash>;
 
public:
 
    typedef
        VdfExecutorDataManager<VdfDataManagerHashTable>
        Base;
 
    typedef
        typename Vdf_ExecutorDataManagerTraits<
            VdfDataManagerHashTable>::DataHandle
        DataHandle;
 
    VDF_API
    void Resize(const VdfNetwork &network);
 
    bool IsValidDataHandle(const DataHandle handle) const {
        return handle != nullptr;
    }
 
    DataHandle GetOrCreateDataHandle(const VdfId outputId) const {
        _DataMap::iterator it = _outputData.find(outputId);
        if (it == _outputData.end()) {
            it = _outputData.emplace(
                std::piecewise_construct,
                std::forward_as_tuple(outputId),
                std::forward_as_tuple())
                    .first;
        }
        return &it->second;
    }
 
    DataHandle GetDataHandle(const VdfId outputId) const {
        return TfMapLookupPtr(_outputData, outputId);
    }
 
    VdfExecutorBufferData * GetBufferData(const DataHandle handle) const {
        return &handle->bufferData;
    }
 
    VdfExecutorInvalidationData * GetInvalidationData(
        const DataHandle handle) const {
        return &handle->invalidationData;
    }
 
    using Base::GetInvalidationTimestamp;
 
    VdfInvalidationTimestamp GetInvalidationTimestamp(
        const DataHandle handle) const {
        return handle->invalidationTimestamp;
    }
 
    void SetInvalidationTimestamp(
        const DataHandle handle,
        VdfInvalidationTimestamp timestamp) {
        handle->invalidationTimestamp = timestamp;
    }
 
    VdfSMBLData * GetSMBLData(const DataHandle handle) const {
        return handle->smblData.get();
    }
 
    VdfSMBLData * GetOrCreateSMBLData(const DataHandle handle) const {
        if (!handle->smblData) {
            handle->smblData.reset(new VdfSMBLData());
        }      
        return handle->smblData.get();
    }
 
    bool IsTouched(const DataHandle handle) const {
        return handle->touched;
    }
 
    void Touch(const DataHandle handle) const {
        handle->touched = true;
    }
 
    bool Untouch(const DataHandle handle) {
        const bool wasTouched = handle->touched;
        handle->touched = false;
        return wasTouched;
    }
 
    void ClearDataForOutput(const VdfId outputId) {
        _outputData.erase(outputId);
    }
 
    void Clear() {
        TfReset(_outputData);
    }
 
    bool IsEmpty() const {
        return _outputData.empty();
    }
 
 
private:
 
    // Map from outputs to their executor data.
    mutable _DataMap _outputData;
 
};
 
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif