readWriteAccessor.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_READ_WRITE_ACCESSOR_H
#define PXR_EXEC_VDF_READ_WRITE_ACCESSOR_H
 
 
#include "pxr/pxr.h"
 
#include "pxr/exec/vdf/context.h"
#include "pxr/exec/vdf/iterator.h"
 
#include "pxr/base/arch/hints.h"
 
PXR_NAMESPACE_OPEN_SCOPE
 
template < typename T >
class VdfReadWriteAccessor : public VdfIterator
{
public:
 
    VdfReadWriteAccessor(const VdfContext &context, const TfToken &name);
 
    VdfReadWriteAccessor(const VdfContext &context) :
        VdfReadWriteAccessor(context, TfToken())
    {}
 
    const T &operator[](size_t index) const {
        return const_cast<VdfReadWriteAccessor *>(this)->operator[](index);
    }
 
    T &operator[](size_t index);
 
    bool IsEmpty() const {
        return GetSize() == 0;
    }
 
    size_t GetSize() const {
        return _size;
    }
 
private:
 
    // The accessor to the output data.
    VdfVector::ReadWriteAccessor<T> _accessor;
 
    // The mask with accessible data elements. All elements are accessible if
    // this mask is empty.
    VdfMask _mask;
 
    // The offset into the data.
    size_t _offset;
 
    // The size of the data.
    size_t _size;
 
};
 
 
template < typename T >
VdfReadWriteAccessor<T>::VdfReadWriteAccessor(
    const VdfContext &context,
    const TfToken &name) :
    _offset(0),
    _size(0)
{
    // Get the required output for writing. This will emit a coding error if
    // there is no valid output.
    const VdfOutput *output = _GetRequiredOutputForWriting(context, name);
    if (!output) {
        return;
    }
 
    // Retrieve the relevant masks at the output. This will return false if the
    // output is not scheduled, i.e. the accessor will remain empty.
    const VdfMask *requestMask = nullptr;
    const VdfMask *affectsMask = nullptr;
    if (!_GetOutputMasks(context, *output, &requestMask, &affectsMask)) {
        return;
    }
 
    // Get the value to write to. It is an error for this value not to be
    // available. The executor engine is responsible for creating it.
    VdfVector *v = _GetOutputValueForWriting(context, *output);
    if (!TF_VERIFY(v, "Output '%s' is missing buffer.",
            output->GetName().GetText())) {
        return;
    }
 
    // Get the accessor to the value.
    _accessor = v->GetReadWriteAccessor<T>();
 
    // If there is an affects mask on this output, and that mask is not
    // all-ones, use the mask to redirect data access. If the mask is
    // contiguous, we can simply use the first index as an offset into the data.
    // The size is the number of bits set on the mask.
    if (affectsMask && !affectsMask->IsAllOnes()) {
        if (affectsMask->IsContiguous()) {
            _offset = affectsMask->GetFirstSet();
        } else {
            _mask = *affectsMask;
        }
        _size = affectsMask->GetNumSet();
    }
 
    // If there is no affects mask, or if the affects mask is all ones we can
    // provide access without redirection. The size is the number of values on
    // the vector accessor.
    else {
        _size = _accessor.GetNumValues();
    }
}
 
template < typename T >
T &
VdfReadWriteAccessor<T>::operator[](size_t index)
{
    // Perform out of bounds check in debug builds.
    TF_DEV_AXIOM(index < GetSize());
 
    // The fast-path is for data that is contiguous in memory. The offset is
    // often 0, but the addition is fast enough to perform indiscriminately and
    // instead of a branch.
    if (ARCH_LIKELY(_mask.IsEmpty())) {
        return _accessor[index + _offset];
    }
 
    // If a mask is used to redirect data access, we need to map the provided
    // index to the n-th set bit in the mask. This is the slow-path.
    return _accessor[_mask.GetBits().FindNthSet(index)];
}
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif