blob: f23d2b094c3d2a8e6c4804c7f006f6c72480edd3 [file] [log] [blame]
/*
* Copyright 2012 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrMemoryPool_DEFINED
#define GrMemoryPool_DEFINED
#include "include/private/base/SkDebug.h"
#include "src/base/SkBlockAllocator.h"
#include <cstddef>
#include <cstdint>
#include <memory>
#include <type_traits>
#ifdef SK_DEBUG
#include "src/core/SkTHash.h"
#endif
/**
* Allocates memory in blocks and parcels out space in the blocks for allocation requests. It is
* optimized for allocate / release speed over memory efficiency. The interface is designed to be
* used to implement operator new and delete overrides. All allocations are expected to be released
* before the pool's destructor is called. Allocations will be aligned to sizeof(std::max_align_t).
*
* All allocated objects must be released back to the memory pool before it can be destroyed.
*/
class GrMemoryPool {
public:
#ifdef SK_FORCE_8_BYTE_ALIGNMENT
// https://github.com/emscripten-core/emscripten/issues/10072
// Since Skia does not use "long double" (16 bytes), we should be ok to force it back to 8 bytes
// until emscripten is fixed.
static constexpr size_t kAlignment = 8;
#else
// Guaranteed alignment of pointer returned by allocate().
static constexpr size_t kAlignment = alignof(std::max_align_t);
#endif
// Smallest block size allocated on the heap (not the smallest reservation via allocate()).
inline static constexpr size_t kMinAllocationSize = 1 << 10;
/**
* Prealloc size is the amount of space to allocate at pool creation
* time and keep around until pool destruction. The min alloc size is
* the smallest allowed size of additional allocations. Both sizes are
* adjusted to ensure that they are at least as large as kMinAllocationSize
* and less than SkBlockAllocator::kMaxAllocationSize.
*
* Both sizes are what the pool will end up allocating from the system, and
* portions of the allocated memory is used for internal bookkeeping.
*/
static std::unique_ptr<GrMemoryPool> Make(size_t preallocSize, size_t minAllocSize);
~GrMemoryPool();
void operator delete(void* p) { ::operator delete(p); }
/**
* Allocates memory. The memory must be freed with release() before the GrMemoryPool is deleted.
*/
void* allocate(size_t size);
/**
* p must have been returned by allocate().
*/
void release(void* p);
/**
* Returns true if there are no unreleased allocations.
*/
bool isEmpty() const {
// If size is the same as preallocSize, there aren't any heap blocks, so currentBlock()
// is the inline head block.
return fAllocator.currentBlock() == fAllocator.headBlock() &&
fAllocator.currentBlock()->metadata() == 0;
}
/**
* In debug mode, this reports the IDs of unfreed nodes via `SkDebugf`. This reporting is also
* performed automatically whenever a GrMemoryPool is destroyed.
* In release mode, this method is a no-op.
*/
void reportLeaks() const;
/**
* Returns the total allocated size of the GrMemoryPool minus any preallocated amount
*/
size_t size() const { return fAllocator.totalSize() - fAllocator.preallocSize(); }
/**
* Returns the preallocated size of the GrMemoryPool
*/
size_t preallocSize() const {
// Account for the debug-only fields in this count, the offset is 0 for release builds
static_assert(std::is_standard_layout<GrMemoryPool>::value, "");
return offsetof(GrMemoryPool, fAllocator) + fAllocator.preallocSize();
}
/**
* Frees any scratch blocks that are no longer being used.
*/
void resetScratchSpace() {
fAllocator.resetScratchSpace();
}
#ifdef SK_DEBUG
void validate() const;
#endif
private:
// Per-allocation overhead so that GrMemoryPool can always identify the block owning each and
// release all occupied bytes, including any resulting from alignment padding.
struct Header {
int fStart;
int fEnd;
#if defined(SK_DEBUG)
int fID; // ID that can be used to track down leaks by clients.
#endif
#if defined(SK_DEBUG) || defined(SK_SANITIZE_ADDRESS)
uint32_t fSentinel; // set to a known value to check for memory stomping; poisoned in ASAN mode
#endif
};
GrMemoryPool(size_t preallocSize, size_t minAllocSize);
#ifdef SK_DEBUG
// Because this exists preallocSize wants to use offsetof, so keep GrMemoryPool standard layout
// without depending on THashSet being standard layout. Note that std::unique_ptr may not be
// standard layout.
struct Debug{
skia_private::THashSet<int> fAllocatedIDs;
int fAllocationCount;
};
Debug* fDebug{nullptr};
#endif
SkBlockAllocator fAllocator; // Must be the last field, in order to use extra allocated space
};
#endif