blob: 74ce03364ab513874e7a3d6d49a5bf57c17c86c3 [file] [log] [blame]
/*
* Copyright 2020 Google LLC
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SKSL_POOL
#define SKSL_POOL
#include "src/sksl/SkSLMemoryPool.h"
#include <stddef.h>
#include <memory>
namespace SkSL {
/**
* Efficiently allocates memory in an SkSL program. Optimized for allocate/release performance over
* memory efficiency.
*
* All allocated memory must be released back to the pool before it can be destroyed or recycled.
*/
class Pool {
public:
~Pool();
// Creates a pool to store objects during program creation. Call attachToThread() to start using
// the pool for its allocations. When your program is complete, call pool->detachFromThread() to
// take ownership of the pool and its allocations. Before freeing any of the program's
// allocations, make sure to reattach the pool by calling pool->attachToThread() again.
static std::unique_ptr<Pool> Create();
// Attaches a pool to the current thread.
// It is an error to call this while a pool is already attached.
void attachToThread();
// Once you are done creating or destroying objects in the pool, detach it from the thread.
// It is an error to call this while no pool is attached.
void detachFromThread();
// Allocates memory from the thread pool. If the pool is exhausted, an additional block of pool
// storage will be created to hold the data.
static void* AllocMemory(size_t size);
// Releases memory that was created by AllocMemory. All objects in the pool must be freed before
// the pool can be destroyed.
static void FreeMemory(void* ptr);
static bool IsAttached();
private:
Pool() = default; // use Create to make a pool
std::unique_ptr<SkSL::MemoryPool> fMemPool;
};
/**
* If your class inherits from Poolable, its objects will be allocated from the pool.
*/
class Poolable {
public:
// Override operator new and delete to allow us to use a memory pool.
static void* operator new(const size_t size) {
return Pool::AllocMemory(size);
}
static void operator delete(void* ptr) {
Pool::FreeMemory(ptr);
}
};
/**
* Temporarily attaches a pool to the current thread within a scope.
*/
class AutoAttachPoolToThread {
public:
AutoAttachPoolToThread(Pool* p) : fPool(p) {
if (fPool) {
fPool->attachToThread();
}
}
~AutoAttachPoolToThread() {
if (fPool) {
fPool->detachFromThread();
}
}
private:
Pool* fPool = nullptr;
};
} // namespace SkSL
#endif