GrBufferAllocPool Class Reference

#include <GrBufferAllocPool.h>

Inheritance diagram for GrBufferAllocPool:

Classes
class	CpuBufferCache

Public Member Functions
void	unmap ()
void	reset ()
void	putBack (size_t bytes)

Static Public Attributes
static constexpr size_t	kDefaultBufferSize = 1 << 15

Protected Member Functions
	GrBufferAllocPool (GrGpu *gpu, GrGpuBufferType bufferType, sk_sp< CpuBufferCache > cpuBufferCache)
virtual	~GrBufferAllocPool ()
void *	makeSpace (size_t size, size_t alignment, sk_sp< const GrBuffer > *buffer, size_t *offset)
void *	makeSpaceAtLeast (size_t minSize, size_t fallbackSize, size_t alignment, sk_sp< const GrBuffer > *buffer, size_t *offset, size_t *actualSize)
sk_sp< GrBuffer >	getBuffer (size_t size)

Detailed Description

A pool of geometry buffers tied to a GrGpu.

The pool allows a client to make space for geometry and then put back excess space if it over allocated. When a client is ready to draw from the pool it calls unmap on the pool ensure buffers are ready for drawing. The pool can be reset after drawing is completed to recycle space.

At creation time a minimum per-buffer size can be specified. Additionally, a number of buffers to preallocate can be specified. These will be allocated at the min size and kept around until the pool is destroyed.

Definition at line 35 of file GrBufferAllocPool.h.

Constructor & Destructor Documentation

GrBufferAllocPool()

GrBufferAllocPool::GrBufferAllocPool ( GrGpu *  gpu, GrGpuBufferType  bufferType, sk_sp< CpuBufferCache >  cpuBufferCache  )

protected

Constructor

Parameters

gpu	The GrGpu used to create the buffers.
bufferType	The type of buffers to create.
cpuBufferCache	If non-null a cache for client side array buffers or staging buffers used before data is uploaded to GPU buffer objects.

Definition at line 88 of file GrBufferAllocPool.cpp.

        : fBlocks(8)
        , fCpuBufferCache(std::move(cpuBufferCache))
        , fGpu(gpu)
        , fBufferType(bufferType) {}

~GrBufferAllocPool()

GrBufferAllocPool::~GrBufferAllocPool ( )

protectedvirtual

Definition at line 108 of file GrBufferAllocPool.cpp.

                                      {
    VALIDATE();
    this->deleteBlocks();
}

Member Function Documentation

getBuffer()

sk_sp< GrBuffer > GrBufferAllocPool::getBuffer ( size_t  size )

protected

Definition at line 413 of file GrBufferAllocPool.cpp.

                                                        {
    const GrCaps& caps = *fGpu->caps();
    auto resourceProvider = fGpu->getContext()->priv().resourceProvider();
    if (caps.preferClientSideDynamicBuffers() ||
        (fBufferType == GrGpuBufferType::kDrawIndirect && caps.useClientSideIndirectBuffers())) {
        // Create a CPU buffer.
        bool mustInitialize = caps.mustClearUploadedBufferData();
        return fCpuBufferCache ? fCpuBufferCache->makeBuffer(size, mustInitialize)
                               : GrCpuBuffer::Make(size);
    }
    return resourceProvider->createBuffer(size,
                                          fBufferType,
                                          kDynamic_GrAccessPattern,
                                          GrResourceProvider::ZeroInit::kNo);
}

makeSpace()

void * GrBufferAllocPool::makeSpace ( size_t  size, size_t  alignment, sk_sp< const GrBuffer > *  buffer, size_t *  offset  )

protected

Returns a block of memory to hold data. A buffer designated to hold the data is given to the caller. The buffer may or may not be locked. The returned ptr remains valid until any of the following: *makeSpace is called again. *unmap is called. *reset is called. *this object is destroyed.

Once unmap on the pool is called the data is guaranteed to be in the buffer at the offset indicated by offset. Until that time it may be in temporary storage and/or the buffer may be locked.

Parameters

size	the amount of data to make space for
alignment	alignment constraint from start of buffer
buffer	returns the buffer that will hold the data.
offset	returns the offset into buffer of the data.

Returns

pointer to where the client should write the data.

Definition at line 189 of file GrBufferAllocPool.cpp.

                                                   {
    VALIDATE();
 
    SkASSERT(buffer);
    SkASSERT(offset);
 
    if (fBufferPtr) {
        BufferBlock& back = fBlocks.back();
        size_t usedBytes = back.fBuffer->size() - back.fBytesFree;
        size_t pad = align_up_pad(usedBytes, alignment);
        SkSafeMath safeMath;
        size_t alignedSize = safeMath.add(pad, size);
        if (!safeMath.ok()) {
            return nullptr;
        }
        if (alignedSize <= back.fBytesFree) {
            memset((void*)(reinterpret_cast<intptr_t>(fBufferPtr) + usedBytes), 0, pad);
            usedBytes += pad;
            *offset = usedBytes;
            *buffer = back.fBuffer;
            back.fBytesFree -= alignedSize;
            fBytesInUse += alignedSize;
            VALIDATE();
            return (void*)(reinterpret_cast<intptr_t>(fBufferPtr) + usedBytes);
        }
    }
 
    // We could honor the space request using by a partial update of the current
    // VB (if there is room). But we don't currently use draw calls to GL that
    // allow the driver to know that previously issued draws won't read from
    // the part of the buffer we update. Also, when this was written the GL
    // buffer implementation was cheating on the actual buffer size by shrinking
    // the buffer in updateData() if the amount of data passed was less than
    // the full buffer size. This is old code and both concerns may be obsolete.
 
    if (!this->createBlock(size)) {
        return nullptr;
    }
    SkASSERT(fBufferPtr);
 
    *offset = 0;
    BufferBlock& back = fBlocks.back();
    *buffer = back.fBuffer;
    back.fBytesFree -= size;
    fBytesInUse += size;
    VALIDATE();
    return fBufferPtr;
}

makeSpaceAtLeast()

void * GrBufferAllocPool::makeSpaceAtLeast ( size_t  minSize, size_t  fallbackSize, size_t  alignment, sk_sp< const GrBuffer > *  buffer, size_t *  offset, size_t *  actualSize  )

protected

Returns a block of memory to hold data. A buffer designated to hold the data is given to the caller. The buffer may or may not be locked. The returned ptr remains valid until any of the following: *makeSpace is called again. *unmap is called. *reset is called. *this object is destroyed.

Once unmap on the pool is called the data is guaranteed to be in the buffer at the offset indicated by offset. Until that time it may be in temporary storage and/or the buffer may be locked.

The caller requests a minimum number of bytes, but the block may be (much) larger. Assuming that a new block must be allocated, it will be fallbackSize bytes. The actual block size is returned in actualSize.

Parameters

minSize	the minimum amount of data to make space for
fallbackSize	the amount of data to make space for if a new block is needed
alignment	alignment constraint from start of buffer
buffer	returns the buffer that will hold the data.
offset	returns the offset into buffer of the data.
actualSize	returns the capacity of the block

Returns

pointer to where the client should write the data.

Definition at line 241 of file GrBufferAllocPool.cpp.

                                                              {
    VALIDATE();
 
    SkASSERT(buffer);
    SkASSERT(offset);
    SkASSERT(actualSize);
 
    size_t usedBytes = (fBlocks.empty()) ? 0 : fBlocks.back().fBuffer->size() -
                                               fBlocks.back().fBytesFree;
    size_t pad = align_up_pad(usedBytes, alignment);
    if (!fBufferPtr || fBlocks.empty() || (minSize + pad) > fBlocks.back().fBytesFree) {
        // We either don't have a block yet or the current block doesn't have enough free space.
        // Create a new one.
        if (!this->createBlock(fallbackSize)) {
            return nullptr;
        }
        usedBytes = 0;
        pad = 0;
    }
    SkASSERT(fBufferPtr);
 
    // Consume padding first, to make subsequent alignment math easier
    memset(static_cast<char*>(fBufferPtr) + usedBytes, 0, pad);
    usedBytes += pad;
    fBlocks.back().fBytesFree -= pad;
    fBytesInUse += pad;
 
    // Give caller all remaining space in this block (but aligned correctly)
    size_t size = align_down(fBlocks.back().fBytesFree, alignment);
    *offset = usedBytes;
    *buffer = fBlocks.back().fBuffer;
    *actualSize = size;
    fBlocks.back().fBytesFree -= size;
    fBytesInUse += size;
    VALIDATE();
    return static_cast<char*>(fBufferPtr) + usedBytes;
}

putBack()

void GrBufferAllocPool::putBack

(

size_t

bytes

)

Frees data from makeSpaces in LIFO order.

Definition at line 284 of file GrBufferAllocPool.cpp.

                                            {
    VALIDATE();
    if (!bytes) {
        return;
    }
    SkASSERT(!fBlocks.empty());
    BufferBlock& block = fBlocks.back();
    // Caller shouldn't try to put back more than they've taken and all those bytes should fit into
    // one block. All the uses of this call are sequential with a single makeSpaceAtLeast call. So
    // we should not have a case where someone is putting back bytes that are greater than the
    // current block.
    // It is possible the caller returns all their allocated bytes thus the <= and not just <.
    SkASSERT(bytes <= (block.fBuffer->size() - block.fBytesFree));
    block.fBytesFree += bytes;
    fBytesInUse -= bytes;
 
    // We don't allow blocks without any used bytes. So if we end up in that case after putting
    // back the bytes then destroy the block. This scenario shouldn't occur often, but even if we
    // end up allocating a new block immediately after destroying this one, the GPU and CPU buffers
    // will usually be cached so the new block shouldn't be too expensive to make.
    // TODO: This was true in older versions and uses of this class but is it still needed to
    // have this restriction?
    if (block.fBytesFree == block.fBuffer->size()) {
        GrBuffer* buffer = block.fBuffer.get();
        if (!buffer->isCpuBuffer() && static_cast<GrGpuBuffer*>(buffer)->isMapped()) {
            UNMAP_BUFFER(block);
        }
        this->destroyBlock();
    }
 
    VALIDATE();
}

reset()

void GrBufferAllocPool::reset

(

)

Invalidates all the data in the pool, unrefs non-preallocated buffers.

Definition at line 113 of file GrBufferAllocPool.cpp.

                              {
    VALIDATE();
    fBytesInUse = 0;
    this->deleteBlocks();
    this->resetCpuData(0);
    VALIDATE();
}

unmap()

void GrBufferAllocPool::unmap

(

)

Ensures all buffers are unmapped and have all data written to them. Call before drawing using buffers from the pool.

Definition at line 121 of file GrBufferAllocPool.cpp.

                              {
    VALIDATE();
 
    if (fBufferPtr) {
        BufferBlock& block = fBlocks.back();
        GrBuffer* buffer = block.fBuffer.get();
        if (!buffer->isCpuBuffer()) {
            if (static_cast<GrGpuBuffer*>(buffer)->isMapped()) {
                UNMAP_BUFFER(block);
            } else {
                size_t flushSize = block.fBuffer->size() - block.fBytesFree;
                this->flushCpuData(fBlocks.back(), flushSize);
            }
        }
        fBufferPtr = nullptr;
    }
    VALIDATE();
}

Member Data Documentation

kDefaultBufferSize

constexpr size_t GrBufferAllocPool::kDefaultBufferSize = 1 << 15

inlinestaticconstexpr

Definition at line 37 of file GrBufferAllocPool.h.

---

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

• third_party/skia/src/gpu/ganesh/GrBufferAllocPool.h
• third_party/skia/src/gpu/ganesh/GrBufferAllocPool.cpp