skgpu::graphite::DawnBuffer Class Reference

#include <DawnBuffer.h>

Inheritance diagram for skgpu::graphite::DawnBuffer:

Public Member Functions
bool	isUnmappable () const override
const wgpu::Buffer &	dawnBuffer () const
Public Member Functions inherited from skgpu::graphite::Buffer
size_t	size () const
void *	map ()
void	asyncMap (GpuFinishedProc=nullptr, GpuFinishedContext=nullptr)
void	unmap ()
bool	isMapped () const
const char *	getResourceType () const override
Public Member Functions inherited from skgpu::graphite::Resource
	Resource (const Resource &)=delete
	Resource (Resource &&)=delete
Resource &	operator= (const Resource &)=delete
Resource &	operator= (Resource &&)=delete
void	ref () const
void	unref () const
void	refCommandBuffer () const
void	unrefCommandBuffer () const
Ownership	ownership () const
skgpu::Budgeted	budgeted () const
size_t	gpuMemorySize () const
UniqueID	uniqueID () const
std::string	getLabel () const
void	setLabel (std::string_view label)
bool	wasDestroyed () const
const GraphiteResourceKey &	key () const
void	setKey (const GraphiteResourceKey &key)
void	dumpMemoryStatistics (SkTraceMemoryDump *traceMemoryDump) const
virtual void	prepareForReturnToCache (const std::function< void()> &takeRef)

Static Public Member Functions
static sk_sp< DawnBuffer >	Make (const DawnSharedContext *, size_t size, BufferType type, AccessPattern, std::string_view label)

Private Member Functions
void	onMap () override
void	onUnmap () override
void	freeGpuData () override
void	onDumpMemoryStatistics (SkTraceMemoryDump *traceMemoryDump, const char *dumpName) const override

Additional Inherited Members
Protected Member Functions inherited from skgpu::graphite::Buffer
	Buffer (const SharedContext *sharedContext, size_t size, std::string_view label, bool commandBufferRefsAsUsageRefs=false)
Protected Member Functions inherited from skgpu::graphite::Resource
	Resource (const SharedContext *, Ownership, skgpu::Budgeted, size_t gpuMemorySize, std::string_view label, bool commandBufferRefsAsUsageRefs=false)
virtual	~Resource ()
const SharedContext *	sharedContext () const
virtual void	invokeReleaseProc ()
void	setDeleteASAP ()
Protected Attributes inherited from skgpu::graphite::Buffer
void *	fMapPtr = nullptr

Detailed Description

Definition at line 23 of file DawnBuffer.h.

Member Function Documentation

dawnBuffer()

const wgpu::Buffer & skgpu::graphite::DawnBuffer::dawnBuffer ( ) const

inline

Definition at line 33 of file DawnBuffer.h.

{ return fBuffer; }

freeGpuData()

void skgpu::graphite::DawnBuffer::freeGpuData ( )

overrideprivatevirtual

Implements skgpu::graphite::Resource.

Definition at line 313 of file DawnBuffer.cpp.

                             {
    fBuffer = nullptr;
}

isUnmappable()

bool skgpu::graphite::DawnBuffer::isUnmappable ( ) const

overridevirtual

Reimplemented from skgpu::graphite::Buffer.

Definition at line 309 of file DawnBuffer.cpp.

                                    {
    return fBuffer.GetMapState() != wgpu::BufferMapState::Unmapped;
}

Make()

sk_sp< DawnBuffer > skgpu::graphite::DawnBuffer::Make ( const DawnSharedContext *  sharedContext, size_t  size, BufferType  type, AccessPattern  accessPattern, std::string_view  label  )

static

Definition at line 30 of file DawnBuffer.cpp.

                                                         {
    if (size <= 0) {
        return nullptr;
    }
 
    wgpu::BufferUsage usage = wgpu::BufferUsage::None;
 
    switch (type) {
    case BufferType::kVertex:
        usage = wgpu::BufferUsage::Vertex | wgpu::BufferUsage::CopyDst;
        break;
    case BufferType::kIndex:
        usage = wgpu::BufferUsage::Index | wgpu::BufferUsage::CopyDst;
        break;
    case BufferType::kXferCpuToGpu:
        usage = wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::MapWrite;
        break;
    case BufferType::kXferGpuToCpu:
        usage = wgpu::BufferUsage::CopyDst | wgpu::BufferUsage::MapRead;
        break;
    case BufferType::kUniform:
        usage = wgpu::BufferUsage::Uniform | wgpu::BufferUsage::CopyDst;
        break;
    case BufferType::kStorage:
        usage = wgpu::BufferUsage::Storage | wgpu::BufferUsage::CopyDst |
                wgpu::BufferUsage::CopySrc;
        break;
    case BufferType::kIndirect:
        usage = wgpu::BufferUsage::Indirect | wgpu::BufferUsage::Storage |
                wgpu::BufferUsage::CopyDst;
        break;
    case BufferType::kVertexStorage:
        usage = wgpu::BufferUsage::Vertex | wgpu::BufferUsage::Storage;
        break;
    case BufferType::kIndexStorage:
        usage = wgpu::BufferUsage::Index | wgpu::BufferUsage::Storage;
        break;
    }
 
    if (sharedContext->caps()->drawBufferCanBeMapped() &&
        accessPattern == AccessPattern::kHostVisible &&
        type != BufferType::kXferGpuToCpu) {
        usage |= wgpu::BufferUsage::MapWrite;
    }
 
    wgpu::BufferDescriptor desc;
#ifdef SK_DEBUG
    desc.label = kBufferTypeNames[static_cast<int>(type)];
#endif
    desc.usage = usage;
    desc.size  = size;
    // Specifying mappedAtCreation avoids clearing the buffer on the GPU which can cause MapAsync to
    // be very slow as it waits for GPU execution to complete.
    desc.mappedAtCreation = SkToBool(usage & wgpu::BufferUsage::MapWrite);
 
    auto buffer = sharedContext->device().CreateBuffer(&desc);
    if (!buffer) {
        return {};
    }
 
    void* mappedAtCreationPtr = nullptr;
    if (desc.mappedAtCreation) {
        mappedAtCreationPtr = buffer.GetMappedRange();
        SkASSERT(mappedAtCreationPtr);
    }
 
    return sk_sp<DawnBuffer>(new DawnBuffer(sharedContext,
                                            size,
                                            std::move(buffer),
                                            type,
                                            mappedAtCreationPtr,
                                            std::move(label)));
}

onDumpMemoryStatistics()

void skgpu::graphite::DawnBuffer::onDumpMemoryStatistics ( SkTraceMemoryDump *  traceMemoryDump, const char *  dumpName  ) const

overrideprivatevirtual

Reimplemented from skgpu::graphite::Resource.

Definition at line 317 of file DawnBuffer.cpp.

                                                                     {
    Buffer::onDumpMemoryStatistics(traceMemoryDump, dumpName);
    traceMemoryDump->dumpStringValue(
            dumpName, "backend_label", kBufferTypeNames[static_cast<int>(fType)]);
}

onMap()

void skgpu::graphite::DawnBuffer::onMap ( )

overrideprivatevirtual

Implements skgpu::graphite::Buffer.

Definition at line 190 of file DawnBuffer.cpp.

                       {
#if defined(__EMSCRIPTEN__)
    SKGPU_LOG_W("Synchronous buffer mapping not supported in Dawn. Failing map request.");
#else
    SkASSERT(!this->sharedContext()->caps()->bufferMapsAreAsync());
    SkASSERT(fBuffer);
    SkASSERT((fBuffer.GetUsage() & wgpu::BufferUsage::MapRead) ||
             (fBuffer.GetUsage() & wgpu::BufferUsage::MapWrite));
    bool isWrite = fBuffer.GetUsage() & wgpu::BufferUsage::MapWrite;
 
    // Use wgpu::Future and WaitAny with timeout=0 to trigger callback immediately.
    // This should work because our resource tracking mechanism should make sure that
    // the buffer is free of any GPU use at this point.
    wgpu::BufferMapCallbackInfo callbackInfo{};
    callbackInfo.mode = wgpu::CallbackMode::WaitAnyOnly;
    callbackInfo.userdata = this;
    callbackInfo.callback = [](WGPUBufferMapAsyncStatus s, void* userData) {
        auto buffer = static_cast<DawnBuffer*>(userData);
        buffer->mapCallback(s);
    };
 
    wgpu::FutureWaitInfo mapWaitInfo{};
 
    mapWaitInfo.future = fBuffer.MapAsync(isWrite ? wgpu::MapMode::Write : wgpu::MapMode::Read,
                                          0,
                                          fBuffer.GetSize(),
                                          callbackInfo);
 
    wgpu::Device device = static_cast<const DawnSharedContext*>(sharedContext())->device();
    wgpu::Instance instance = device.GetAdapter().GetInstance();
    [[maybe_unused]] auto status = instance.WaitAny(1, &mapWaitInfo, /*timeoutNS=*/0);
 
    if (status != wgpu::WaitStatus::Success) {
        // WaitAny(timeout=0) might fail in this scenario:
        // - Allocates a buffer.
        // - Encodes a command buffer to copy a texture to this buffer.
        // - Submits the command buffer. If OOM happens, this command buffer will fail to
        // be submitted.
        // - The buffer is *supposed* to be free of any GPU use since the command buffer that would
        // have used it wasn't submitted successfully.
        // - If we try to map this buffer at this point, internally Dawn will try to use GPU to
        // clear this buffer to zeros, since this is its 1st use. WaitAny(timeout=0) won't work
        // since the buffer now has a pending GPU clear operation.
        //
        // To work around this, we need to try again with a blocking WaitAny(), to wait for the
        // clear operation to finish.
        // Notes:
        // - This fallback should be rare since it is caused by an OOM error during buffer
        // readbacks.
        // - For buffer writing cases, since we use mappedAtCreation, the GPU clear won't happen.
        status = instance.WaitAny(
                1, &mapWaitInfo, /*timeoutNS=*/std::numeric_limits<uint64_t>::max());
    }
 
    SkASSERT(status == wgpu::WaitStatus::Success);
    SkASSERT(mapWaitInfo.completed);
#endif  // defined(__EMSCRIPTEN__)
}

onUnmap()

void skgpu::graphite::DawnBuffer::onUnmap ( )

overrideprivatevirtual

Implements skgpu::graphite::Buffer.

Definition at line 249 of file DawnBuffer.cpp.

                         {
    SkASSERT(fBuffer);
    SkASSERT(this->isUnmappable());
 
    fMapPtr = nullptr;
    fBuffer.Unmap();
}

---

The documentation for this class was generated from the following files:

• third_party/skia/src/gpu/graphite/dawn/DawnBuffer.h
• third_party/skia/src/gpu/graphite/dawn/DawnBuffer.cpp