SkSLPool.h

Go to the documentation of this file.

/*
 * 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 <cstddef>
#include <memory>
 
namespace SkSL {
 
class MemoryPool;
 
/**
 * 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();  // 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