aosp12/external/skia/tests/GrBlockAllocatorTest.cpp

655 lines
26 KiB
C++
Raw Normal View History

2023-01-09 17:11:35 +08:00
/*
* Copyright 2020 Google LLC
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "src/gpu/GrBlockAllocator.h"
#include "tests/Test.h"
#include <cstring>
using Block = GrBlockAllocator::Block;
using GrowthPolicy = GrBlockAllocator::GrowthPolicy;
// Helper functions for modifying the allocator in a controlled manner
template<size_t N>
static int block_count(const GrSBlockAllocator<N>& pool) {
int ct = 0;
for (const Block* b : pool->blocks()) {
(void) b;
ct++;
}
return ct;
}
template<size_t N>
static Block* get_block(GrSBlockAllocator<N>& pool, int blockIndex) {
Block* found = nullptr;
int i = 0;
for (Block* b: pool->blocks()) {
if (i == blockIndex) {
found = b;
break;
}
i++;
}
SkASSERT(found != nullptr);
return found;
}
// GrBlockAllocator holds on to the largest last-released block to reuse for new allocations,
// and this is still counted in its totalSize(). However, it's easier to reason about size - scratch
// in many of these tests.
template<size_t N>
static size_t total_size(GrSBlockAllocator<N>& pool) {
return pool->totalSize() - pool->testingOnly_scratchBlockSize();
}
template<size_t N>
static size_t add_block(GrSBlockAllocator<N>& pool) {
size_t currentSize = total_size(pool);
GrBlockAllocator::Block* current = pool->currentBlock();
while(pool->currentBlock() == current) {
pool->template allocate<4>(pool->preallocSize() / 2);
}
return total_size(pool) - currentSize;
}
template<size_t N>
static void* alloc_byte(GrSBlockAllocator<N>& pool) {
auto br = pool->template allocate<1>(1);
return br.fBlock->ptr(br.fAlignedOffset);
}
DEF_TEST(GrBlockAllocatorPreallocSize, r) {
// Tests stack/member initialization, option #1 described in doc
GrBlockAllocator stack{GrowthPolicy::kFixed, 2048};
SkDEBUGCODE(stack.validate();)
REPORTER_ASSERT(r, stack.preallocSize() == sizeof(GrBlockAllocator));
REPORTER_ASSERT(r, stack.preallocUsableSpace() == (size_t) stack.currentBlock()->avail());
// Tests placement new initialization to increase head block size, option #2
void* mem = operator new(1024);
GrBlockAllocator* placement = new (mem) GrBlockAllocator(GrowthPolicy::kLinear, 1024,
1024 - sizeof(GrBlockAllocator));
REPORTER_ASSERT(r, placement->preallocSize() == 1024);
REPORTER_ASSERT(r, placement->preallocUsableSpace() < 1024 &&
placement->preallocUsableSpace() >= (1024 - sizeof(GrBlockAllocator)));
delete placement;
// Tests inline increased preallocation, option #3
GrSBlockAllocator<2048> inlined{};
SkDEBUGCODE(inlined->validate();)
REPORTER_ASSERT(r, inlined->preallocSize() == 2048);
REPORTER_ASSERT(r, inlined->preallocUsableSpace() < 2048 &&
inlined->preallocUsableSpace() >= (2048 - sizeof(GrBlockAllocator)));
}
DEF_TEST(GrBlockAllocatorAlloc, r) {
GrSBlockAllocator<1024> pool{};
SkDEBUGCODE(pool->validate();)
// Assumes the previous pointer was in the same block
auto validate_ptr = [&](int align, int size,
GrBlockAllocator::ByteRange br,
GrBlockAllocator::ByteRange* prevBR) {
uintptr_t pt = reinterpret_cast<uintptr_t>(br.fBlock->ptr(br.fAlignedOffset));
// Matches the requested align
REPORTER_ASSERT(r, pt % align == 0);
// And large enough
REPORTER_ASSERT(r, br.fEnd - br.fAlignedOffset >= size);
// And has enough padding for alignment
REPORTER_ASSERT(r, br.fAlignedOffset - br.fStart >= 0);
REPORTER_ASSERT(r, br.fAlignedOffset - br.fStart <= align - 1);
// And block of the returned struct is the current block of the allocator
REPORTER_ASSERT(r, pool->currentBlock() == br.fBlock);
// And make sure that we're past the required end of the previous allocation
if (prevBR) {
uintptr_t prevEnd =
reinterpret_cast<uintptr_t>(prevBR->fBlock->ptr(prevBR->fEnd - 1));
REPORTER_ASSERT(r, pt > prevEnd);
}
// And make sure that the entire byte range is safe to write into (excluding the dead space
// between "start" and "aligned offset," which is just padding and is left poisoned)
std::memset(br.fBlock->ptr(br.fAlignedOffset), 0xFF, br.fEnd - br.fAlignedOffset);
};
auto p1 = pool->allocate<1>(14);
validate_ptr(1, 14, p1, nullptr);
auto p2 = pool->allocate<2>(24);
validate_ptr(2, 24, p2, &p1);
auto p4 = pool->allocate<4>(28);
validate_ptr(4, 28, p4, &p2);
auto p8 = pool->allocate<8>(40);
validate_ptr(8, 40, p8, &p4);
auto p16 = pool->allocate<16>(64);
validate_ptr(16, 64, p16, &p8);
auto p32 = pool->allocate<32>(96);
validate_ptr(32, 96, p32, &p16);
// All of these allocations should be in the head block
REPORTER_ASSERT(r, total_size(pool) == pool->preallocSize());
SkDEBUGCODE(pool->validate();)
// Requesting an allocation of avail() should not make a new block
size_t avail = pool->currentBlock()->avail<4>();
auto pAvail = pool->allocate<4>(avail);
validate_ptr(4, avail, pAvail, &p32);
// Remaining should be less than the alignment that was requested, and then
// the next allocation will make a new block
REPORTER_ASSERT(r, pool->currentBlock()->avail<4>() < 4);
auto pNextBlock = pool->allocate<4>(4);
validate_ptr(4, 4, pNextBlock, nullptr);
REPORTER_ASSERT(r, total_size(pool) > pool->preallocSize());
// Allocating more than avail() makes an another block
size_t currentSize = total_size(pool);
size_t bigRequest = pool->currentBlock()->avail<4>() * 2;
auto pTooBig = pool->allocate<4>(bigRequest);
validate_ptr(4, bigRequest, pTooBig, nullptr);
REPORTER_ASSERT(r, total_size(pool) > currentSize);
// Allocating more than the default growth policy (1024 in this case), will fulfill the request
REPORTER_ASSERT(r, total_size(pool) - currentSize < 4096);
currentSize = total_size(pool);
auto pReallyTooBig = pool->allocate<4>(4096);
validate_ptr(4, 4096, pReallyTooBig, nullptr);
REPORTER_ASSERT(r, total_size(pool) >= currentSize + 4096);
SkDEBUGCODE(pool->validate();)
}
DEF_TEST(GrBlockAllocatorResize, r) {
GrSBlockAllocator<1024> pool{};
SkDEBUGCODE(pool->validate();)
// Fixed resize from 16 to 32
GrBlockAllocator::ByteRange p = pool->allocate<4>(16);
REPORTER_ASSERT(r, p.fBlock->avail<4>() > 16);
REPORTER_ASSERT(r, p.fBlock->resize(p.fStart, p.fEnd, 16));
p.fEnd += 16;
std::memset(p.fBlock->ptr(p.fAlignedOffset), 0x11, p.fEnd - p.fAlignedOffset);
// Subsequent allocation is 32 bytes ahead of 'p' now, and 'p' cannot be resized further.
auto pNext = pool->allocate<4>(16);
REPORTER_ASSERT(r, reinterpret_cast<uintptr_t>(pNext.fBlock->ptr(pNext.fAlignedOffset)) -
reinterpret_cast<uintptr_t>(pNext.fBlock->ptr(p.fAlignedOffset)) == 32);
REPORTER_ASSERT(r, p.fBlock == pNext.fBlock);
REPORTER_ASSERT(r, !p.fBlock->resize(p.fStart, p.fEnd, 48));
// Confirm that releasing pNext allows 'p' to be resized, and that it can be resized up to avail
REPORTER_ASSERT(r, p.fBlock->release(pNext.fStart, pNext.fEnd));
int fillBlock = p.fBlock->avail<4>();
REPORTER_ASSERT(r, p.fBlock->resize(p.fStart, p.fEnd, fillBlock));
p.fEnd += fillBlock;
std::memset(p.fBlock->ptr(p.fAlignedOffset), 0x22, p.fEnd - p.fAlignedOffset);
// Confirm that resizing when there's not enough room fails
REPORTER_ASSERT(r, p.fBlock->avail<4>() < fillBlock);
REPORTER_ASSERT(r, !p.fBlock->resize(p.fStart, p.fEnd, fillBlock));
// Confirm that we can shrink 'p' back to 32 bytes and then further allocate again
int shrinkTo32 = p.fStart - p.fEnd + 32;
REPORTER_ASSERT(r, p.fBlock->resize(p.fStart, p.fEnd, shrinkTo32));
p.fEnd += shrinkTo32;
REPORTER_ASSERT(r, p.fEnd - p.fStart == 32);
std::memset(p.fBlock->ptr(p.fAlignedOffset), 0x33, p.fEnd - p.fAlignedOffset);
pNext = pool->allocate<4>(16);
REPORTER_ASSERT(r, reinterpret_cast<uintptr_t>(pNext.fBlock->ptr(pNext.fAlignedOffset)) -
reinterpret_cast<uintptr_t>(pNext.fBlock->ptr(p.fAlignedOffset)) == 32);
SkDEBUGCODE(pool->validate();)
// Confirm that we can't shrink past the start of the allocation, but we can shrink it to 0
int shrinkTo0 = pNext.fStart - pNext.fEnd;
#ifndef SK_DEBUG
// Only test for false on release builds; a negative size should assert on debug builds
REPORTER_ASSERT(r, !pNext.fBlock->resize(pNext.fStart, pNext.fEnd, shrinkTo0 - 1));
#endif
REPORTER_ASSERT(r, pNext.fBlock->resize(pNext.fStart, pNext.fEnd, shrinkTo0));
}
DEF_TEST(GrBlockAllocatorRelease, r) {
GrSBlockAllocator<1024> pool{};
SkDEBUGCODE(pool->validate();)
// Successful allocate and release
auto p = pool->allocate<8>(32);
REPORTER_ASSERT(r, pool->currentBlock()->release(p.fStart, p.fEnd));
// Ensure the above release actually means the next allocation reuses the same space
auto p2 = pool->allocate<8>(32);
REPORTER_ASSERT(r, p.fStart == p2.fStart);
// Confirm that 'p2' cannot be released if another allocation came after it
auto p3 = pool->allocate<8>(64);
(void) p3;
REPORTER_ASSERT(r, !p2.fBlock->release(p2.fStart, p2.fEnd));
// Confirm that 'p4' can be released if 'p5' is released first, and confirm that 'p2' and 'p3'
// can be released simultaneously (equivalent to 'p3' then 'p2').
auto p4 = pool->allocate<8>(16);
auto p5 = pool->allocate<8>(96);
REPORTER_ASSERT(r, p5.fBlock->release(p5.fStart, p5.fEnd));
REPORTER_ASSERT(r, p4.fBlock->release(p4.fStart, p4.fEnd));
REPORTER_ASSERT(r, p2.fBlock->release(p2.fStart, p3.fEnd));
// And confirm that passing in the wrong size for the allocation fails
p = pool->allocate<8>(32);
REPORTER_ASSERT(r, !p.fBlock->release(p.fStart, p.fEnd - 16));
REPORTER_ASSERT(r, !p.fBlock->release(p.fStart, p.fEnd + 16));
REPORTER_ASSERT(r, p.fBlock->release(p.fStart, p.fEnd));
SkDEBUGCODE(pool->validate();)
}
DEF_TEST(GrBlockAllocatorRewind, r) {
// Confirm that a bunch of allocations and then releases in stack order fully goes back to the
// start of the block (i.e. unwinds the entire stack, and not just the last cursor position)
GrSBlockAllocator<1024> pool{};
SkDEBUGCODE(pool->validate();)
std::vector<GrBlockAllocator::ByteRange> ptrs;
for (int i = 0; i < 32; ++i) {
ptrs.push_back(pool->allocate<4>(16));
}
// Release everything in reverse order
SkDEBUGCODE(pool->validate();)
for (int i = 31; i >= 0; --i) {
auto br = ptrs[i];
REPORTER_ASSERT(r, br.fBlock->release(br.fStart, br.fEnd));
}
// If correct, we've rewound all the way back to the start of the block, so a new allocation
// will have the same location as ptrs[0]
SkDEBUGCODE(pool->validate();)
REPORTER_ASSERT(r, pool->allocate<4>(16).fStart == ptrs[0].fStart);
}
DEF_TEST(GrBlockAllocatorGrowthPolicy, r) {
static constexpr int kInitSize = 128;
static constexpr int kBlockCount = 5;
static constexpr size_t kExpectedSizes[GrBlockAllocator::kGrowthPolicyCount][kBlockCount] = {
// kFixed -> kInitSize per block
{ kInitSize, kInitSize, kInitSize, kInitSize, kInitSize },
// kLinear -> (block ct + 1) * kInitSize for next block
{ kInitSize, 2 * kInitSize, 3 * kInitSize, 4 * kInitSize, 5 * kInitSize },
// kFibonacci -> 1, 1, 2, 3, 5 * kInitSize for the blocks
{ kInitSize, kInitSize, 2 * kInitSize, 3 * kInitSize, 5 * kInitSize },
// kExponential -> 1, 2, 4, 8, 16 * kInitSize for the blocks
{ kInitSize, 2 * kInitSize, 4 * kInitSize, 8 * kInitSize, 16 * kInitSize },
};
for (int gp = 0; gp < GrBlockAllocator::kGrowthPolicyCount; ++gp) {
GrSBlockAllocator<kInitSize> pool{(GrowthPolicy) gp};
SkDEBUGCODE(pool->validate();)
REPORTER_ASSERT(r, kExpectedSizes[gp][0] == total_size(pool));
for (int i = 1; i < kBlockCount; ++i) {
REPORTER_ASSERT(r, kExpectedSizes[gp][i] == add_block(pool));
}
SkDEBUGCODE(pool->validate();)
}
}
DEF_TEST(GrBlockAllocatorReset, r) {
static constexpr int kBlockIncrement = 1024;
GrSBlockAllocator<kBlockIncrement> pool{GrowthPolicy::kLinear};
SkDEBUGCODE(pool->validate();)
void* firstAlloc = alloc_byte(pool);
// Add several blocks
add_block(pool);
add_block(pool);
add_block(pool);
SkDEBUGCODE(pool->validate();)
REPORTER_ASSERT(r, block_count(pool) == 4); // 3 added plus the implicit head
get_block(pool, 0)->setMetadata(2);
// Reset and confirm that there's only one block, a new allocation matches 'firstAlloc' again,
// and new blocks are sized based on a reset growth policy.
pool->reset();
SkDEBUGCODE(pool->validate();)
REPORTER_ASSERT(r,block_count(pool) == 1);
REPORTER_ASSERT(r, pool->preallocSize() == pool->totalSize());
REPORTER_ASSERT(r, get_block(pool, 0)->metadata() == 0);
REPORTER_ASSERT(r, firstAlloc == alloc_byte(pool));
REPORTER_ASSERT(r, 2 * kBlockIncrement == add_block(pool));
REPORTER_ASSERT(r, 3 * kBlockIncrement == add_block(pool));
SkDEBUGCODE(pool->validate();)
}
DEF_TEST(GrBlockAllocatorReleaseBlock, r) {
// This loops over all growth policies to make sure that the incremental releases update the
// sequence correctly for each policy.
for (int gp = 0; gp < GrBlockAllocator::kGrowthPolicyCount; ++gp) {
GrSBlockAllocator<1024> pool{(GrowthPolicy) gp};
SkDEBUGCODE(pool->validate();)
void* firstAlloc = alloc_byte(pool);
size_t b1Size = total_size(pool);
size_t b2Size = add_block(pool);
size_t b3Size = add_block(pool);
size_t b4Size = add_block(pool);
SkDEBUGCODE(pool->validate();)
get_block(pool, 0)->setMetadata(1);
get_block(pool, 1)->setMetadata(2);
get_block(pool, 2)->setMetadata(3);
get_block(pool, 3)->setMetadata(4);
// Remove the 3 added blocks, but always remove the i = 1 to test intermediate removal (and
// on the last iteration, will test tail removal).
REPORTER_ASSERT(r, total_size(pool) == b1Size + b2Size + b3Size + b4Size);
pool->releaseBlock(get_block(pool, 1));
REPORTER_ASSERT(r, block_count(pool) == 3);
REPORTER_ASSERT(r, get_block(pool, 1)->metadata() == 3);
REPORTER_ASSERT(r, total_size(pool) == b1Size + b3Size + b4Size);
pool->releaseBlock(get_block(pool, 1));
REPORTER_ASSERT(r, block_count(pool) == 2);
REPORTER_ASSERT(r, get_block(pool, 1)->metadata() == 4);
REPORTER_ASSERT(r, total_size(pool) == b1Size + b4Size);
pool->releaseBlock(get_block(pool, 1));
REPORTER_ASSERT(r, block_count(pool) == 1);
REPORTER_ASSERT(r, total_size(pool) == b1Size);
// Since we're back to just the head block, if we add a new block, the growth policy should
// match the original sequence instead of continuing with "b5Size'"
pool->resetScratchSpace();
size_t size = add_block(pool);
REPORTER_ASSERT(r, size == b2Size);
pool->releaseBlock(get_block(pool, 1));
// Explicitly release the head block and confirm it's reset
pool->releaseBlock(get_block(pool, 0));
REPORTER_ASSERT(r, total_size(pool) == pool->preallocSize());
REPORTER_ASSERT(r, block_count(pool) == 1);
REPORTER_ASSERT(r, firstAlloc == alloc_byte(pool));
REPORTER_ASSERT(r, get_block(pool, 0)->metadata() == 0); // metadata reset too
// Confirm that if we have > 1 block, but release the head block we can still access the
// others
add_block(pool);
add_block(pool);
pool->releaseBlock(get_block(pool, 0));
REPORTER_ASSERT(r, block_count(pool) == 3);
SkDEBUGCODE(pool->validate();)
}
}
DEF_TEST(GrBlockAllocatorIterateAndRelease, r) {
GrSBlockAllocator<256> pool;
pool->headBlock()->setMetadata(1);
add_block(pool);
add_block(pool);
add_block(pool);
// Loop forward and release the blocks
int releaseCount = 0;
for (auto* b : pool->blocks()) {
pool->releaseBlock(b);
releaseCount++;
}
REPORTER_ASSERT(r, releaseCount == 4);
// pool should have just the head block, but was reset
REPORTER_ASSERT(r, pool->headBlock()->metadata() == 0);
REPORTER_ASSERT(r, block_count(pool) == 1);
// Add more blocks
pool->headBlock()->setMetadata(1);
add_block(pool);
add_block(pool);
add_block(pool);
// Loop in reverse and release the blocks
releaseCount = 0;
for (auto* b : pool->rblocks()) {
pool->releaseBlock(b);
releaseCount++;
}
REPORTER_ASSERT(r, releaseCount == 4);
// pool should have just the head block, but was reset
REPORTER_ASSERT(r, pool->headBlock()->metadata() == 0);
REPORTER_ASSERT(r, block_count(pool) == 1);
}
DEF_TEST(GrBlockAllocatorScratchBlockReserve, r) {
GrSBlockAllocator<256> pool;
size_t added = add_block(pool);
REPORTER_ASSERT(r, pool->testingOnly_scratchBlockSize() == 0);
size_t total = pool->totalSize();
pool->releaseBlock(pool->currentBlock());
// Total size shouldn't have changed, the released block should become scratch
REPORTER_ASSERT(r, pool->totalSize() == total);
REPORTER_ASSERT(r, (size_t) pool->testingOnly_scratchBlockSize() == added);
// But a reset definitely deletes any scratch block
pool->reset();
REPORTER_ASSERT(r, pool->testingOnly_scratchBlockSize() == 0);
// Reserving more than what's available adds a scratch block, and current block remains avail.
size_t avail = pool->currentBlock()->avail();
size_t reserve = avail + 1;
pool->reserve(reserve);
REPORTER_ASSERT(r, (size_t) pool->currentBlock()->avail() == avail);
// And rounds up to the fixed size of this pool's growth policy
REPORTER_ASSERT(r, (size_t) pool->testingOnly_scratchBlockSize() >= reserve &&
pool->testingOnly_scratchBlockSize() % 256 == 0);
// Allocating more than avail activates the scratch block (so totalSize doesn't change)
size_t preAllocTotalSize = pool->totalSize();
pool->allocate<1>(avail + 1);
REPORTER_ASSERT(r, (size_t) pool->testingOnly_scratchBlockSize() == 0);
REPORTER_ASSERT(r, pool->totalSize() == preAllocTotalSize);
// When reserving less than what's still available in the current block, no scratch block is
// added.
pool->reserve(pool->currentBlock()->avail());
REPORTER_ASSERT(r, pool->testingOnly_scratchBlockSize() == 0);
// Unless checking available bytes is disabled
pool->reserve(pool->currentBlock()->avail(), GrBlockAllocator::kIgnoreExistingBytes_Flag);
REPORTER_ASSERT(r, pool->testingOnly_scratchBlockSize() > 0);
// If kIgnoreGrowthPolicy is specified, the new scratch block should not have been updated to
// follow the size (which in this case is a fixed 256 bytes per block).
pool->resetScratchSpace();
pool->reserve(32, GrBlockAllocator::kIgnoreGrowthPolicy_Flag);
REPORTER_ASSERT(r, pool->testingOnly_scratchBlockSize() > 0 &&
pool->testingOnly_scratchBlockSize() < 256);
// When requesting an allocation larger than the current block and the scratch block, a new
// block is added, and the scratch block remains scratch.
GrBlockAllocator::Block* oldTail = pool->currentBlock();
avail = oldTail->avail();
size_t scratchAvail = 2 * avail;
pool->reserve(scratchAvail);
REPORTER_ASSERT(r, (size_t) pool->testingOnly_scratchBlockSize() >= scratchAvail);
// This allocation request is higher than oldTail's available, and the scratch size so we
// should add a new block and scratch size should stay the same.
scratchAvail = pool->testingOnly_scratchBlockSize();
pool->allocate<1>(scratchAvail + 1);
REPORTER_ASSERT(r, pool->currentBlock() != oldTail);
REPORTER_ASSERT(r, (size_t) pool->testingOnly_scratchBlockSize() == scratchAvail);
}
DEF_TEST(GrBlockAllocatorStealBlocks, r) {
GrSBlockAllocator<256> poolA;
GrSBlockAllocator<128> poolB;
add_block(poolA);
add_block(poolA);
add_block(poolA);
add_block(poolB);
add_block(poolB);
char* bAlloc = (char*) alloc_byte(poolB);
*bAlloc = 't';
const GrBlockAllocator::Block* allocOwner = poolB->findOwningBlock(bAlloc);
REPORTER_ASSERT(r, block_count(poolA) == 4);
REPORTER_ASSERT(r, block_count(poolB) == 3);
size_t aSize = poolA->totalSize();
size_t bSize = poolB->totalSize();
size_t theftSize = bSize - poolB->preallocSize();
// This steal should move B's 2 heap blocks to A, bringing A to 6 and B to just its head
poolA->stealHeapBlocks(poolB.allocator());
REPORTER_ASSERT(r, block_count(poolA) == 6);
REPORTER_ASSERT(r, block_count(poolB) == 1);
REPORTER_ASSERT(r, poolB->preallocSize() == poolB->totalSize());
REPORTER_ASSERT(r, poolA->totalSize() == aSize + theftSize);
REPORTER_ASSERT(r, *bAlloc == 't');
REPORTER_ASSERT(r, (uintptr_t) poolA->findOwningBlock(bAlloc) == (uintptr_t) allocOwner);
REPORTER_ASSERT(r, !poolB->findOwningBlock(bAlloc));
// Redoing the steal now that B is just a head block should be a no-op
poolA->stealHeapBlocks(poolB.allocator());
REPORTER_ASSERT(r, block_count(poolA) == 6);
REPORTER_ASSERT(r, block_count(poolB) == 1);
}
// These tests ensure that the allocation padding mechanism works as intended
struct TestMeta {
int fX1;
int fX2;
};
struct alignas(32) TestMetaBig {
int fX1;
int fX2;
};
DEF_TEST(GrBlockAllocatorMetadata, r) {
GrSBlockAllocator<1024> pool{};
SkDEBUGCODE(pool->validate();)
// Allocation where alignment of user data > alignment of metadata
SkASSERT(alignof(TestMeta) < 16);
auto p1 = pool->allocate<16, sizeof(TestMeta)>(16);
SkDEBUGCODE(pool->validate();)
REPORTER_ASSERT(r, p1.fAlignedOffset - p1.fStart >= (int) sizeof(TestMeta));
TestMeta* meta = static_cast<TestMeta*>(p1.fBlock->ptr(p1.fAlignedOffset - sizeof(TestMeta)));
// Confirm alignment for both pointers
REPORTER_ASSERT(r, reinterpret_cast<uintptr_t>(meta) % alignof(TestMeta) == 0);
REPORTER_ASSERT(r, reinterpret_cast<uintptr_t>(p1.fBlock->ptr(p1.fAlignedOffset)) % 16 == 0);
// Access fields to make sure 'meta' matches compilers expectations...
meta->fX1 = 2;
meta->fX2 = 5;
// Repeat, but for metadata that has a larger alignment than the allocation
SkASSERT(alignof(TestMetaBig) == 32);
auto p2 = pool->allocate<alignof(TestMetaBig), sizeof(TestMetaBig)>(16);
SkDEBUGCODE(pool->validate();)
REPORTER_ASSERT(r, p2.fAlignedOffset - p2.fStart >= (int) sizeof(TestMetaBig));
TestMetaBig* metaBig = static_cast<TestMetaBig*>(
p2.fBlock->ptr(p2.fAlignedOffset - sizeof(TestMetaBig)));
// Confirm alignment for both pointers
REPORTER_ASSERT(r, reinterpret_cast<uintptr_t>(metaBig) % alignof(TestMetaBig) == 0);
REPORTER_ASSERT(r, reinterpret_cast<uintptr_t>(p2.fBlock->ptr(p2.fAlignedOffset)) % 16 == 0);
// Access fields
metaBig->fX1 = 3;
metaBig->fX2 = 6;
// Ensure metadata values persist after allocations
REPORTER_ASSERT(r, meta->fX1 == 2 && meta->fX2 == 5);
REPORTER_ASSERT(r, metaBig->fX1 == 3 && metaBig->fX2 == 6);
}
DEF_TEST(GrBlockAllocatorAllocatorMetadata, r) {
GrSBlockAllocator<256> pool{};
SkDEBUGCODE(pool->validate();)
REPORTER_ASSERT(r, pool->metadata() == 0); // initial value
pool->setMetadata(4);
REPORTER_ASSERT(r, pool->metadata() == 4);
// Releasing the head block doesn't change the allocator's metadata (even though that's where
// it is stored).
pool->releaseBlock(pool->headBlock());
REPORTER_ASSERT(r, pool->metadata() == 4);
// But resetting the whole allocator brings things back to as if it were newly constructed
pool->reset();
REPORTER_ASSERT(r, pool->metadata() == 0);
}
template<size_t Align, size_t Padding>
static void run_owning_block_test(skiatest::Reporter* r, GrBlockAllocator* pool) {
auto br = pool->allocate<Align, Padding>(1);
void* userPtr = br.fBlock->ptr(br.fAlignedOffset);
void* metaPtr = br.fBlock->ptr(br.fAlignedOffset - Padding);
Block* block = pool->owningBlock<Align, Padding>(userPtr, br.fStart);
REPORTER_ASSERT(r, block == br.fBlock);
block = pool->owningBlock<Align>(metaPtr, br.fStart);
REPORTER_ASSERT(r, block == br.fBlock);
block = reinterpret_cast<Block*>(reinterpret_cast<uintptr_t>(userPtr) - br.fAlignedOffset);
REPORTER_ASSERT(r, block == br.fBlock);
}
template<size_t Padding>
static void run_owning_block_tests(skiatest::Reporter* r, GrBlockAllocator* pool) {
run_owning_block_test<1, Padding>(r, pool);
run_owning_block_test<2, Padding>(r, pool);
run_owning_block_test<4, Padding>(r, pool);
run_owning_block_test<8, Padding>(r, pool);
run_owning_block_test<16, Padding>(r, pool);
run_owning_block_test<32, Padding>(r, pool);
run_owning_block_test<64, Padding>(r, pool);
run_owning_block_test<128, Padding>(r, pool);
}
DEF_TEST(GrBlockAllocatorOwningBlock, r) {
GrSBlockAllocator<1024> pool{};
SkDEBUGCODE(pool->validate();)
run_owning_block_tests<1>(r, pool.allocator());
run_owning_block_tests<2>(r, pool.allocator());
run_owning_block_tests<4>(r, pool.allocator());
run_owning_block_tests<8>(r, pool.allocator());
run_owning_block_tests<16>(r, pool.allocator());
run_owning_block_tests<32>(r, pool.allocator());
// And some weird numbers
run_owning_block_tests<3>(r, pool.allocator());
run_owning_block_tests<9>(r, pool.allocator());
run_owning_block_tests<17>(r, pool.allocator());
}