#ifndef WTF_MetaAllocator_h
#define WTF_MetaAllocator_h
#include <wtf/Assertions.h>
#include <wtf/HashMap.h>
#include <wtf/Lock.h>
#include <wtf/MetaAllocatorHandle.h>
#include <wtf/Noncopyable.h>
#include <wtf/PageBlock.h>
#include <wtf/RedBlackTree.h>
#include <wtf/RefPtr.h>
namespace WTF {
#define ENABLE_META_ALLOCATOR_PROFILE 0
class MetaAllocatorTracker {
WTF_MAKE_FAST_ALLOCATED;
public:
void notify(MetaAllocatorHandle*);
void release(MetaAllocatorHandle*);
MetaAllocatorHandle* find(void* address)
{
MetaAllocatorHandle* handle = m_allocations.findGreatestLessThanOrEqual(address);
if (handle && address < handle->end())
return handle;
return 0;
}
RedBlackTree<MetaAllocatorHandle, void*> m_allocations;
};
class MetaAllocator {
WTF_MAKE_NONCOPYABLE(MetaAllocator);
public:
WTF_EXPORT_PRIVATE MetaAllocator(size_t allocationGranule, size_t pageSize = WTF::pageSize());
WTF_EXPORT_PRIVATE virtual ~MetaAllocator();
WTF_EXPORT_PRIVATE RefPtr<MetaAllocatorHandle> allocate(size_t sizeInBytes, void* ownerUID);
void trackAllocations(MetaAllocatorTracker* tracker)
{
m_tracker = tracker;
}
size_t bytesAllocated() { return m_bytesAllocated; }
size_t bytesReserved() { return m_bytesReserved; }
size_t bytesCommitted() { return m_bytesCommitted; }
struct Statistics {
size_t bytesAllocated;
size_t bytesReserved;
size_t bytesCommitted;
};
WTF_EXPORT_PRIVATE Statistics currentStatistics();
WTF_EXPORT_PRIVATE void addFreshFreeSpace(void* start, size_t sizeInBytes);
WTF_EXPORT_PRIVATE size_t debugFreeSpaceSize();
Lock& getLock() { return m_lock; }
WTF_EXPORT_PRIVATE bool isInAllocatedMemory(const AbstractLocker&, void* address);
#if ENABLE(META_ALLOCATOR_PROFILE)
void dumpProfile();
#else
void dumpProfile() { }
#endif
protected:
virtual void* allocateNewSpace(size_t& numPages) = 0;
virtual void notifyNeedPage(void* page) = 0;
virtual void notifyPageIsFree(void* page) = 0;
private:
friend class MetaAllocatorHandle;
class FreeSpaceNode : public RedBlackTree<FreeSpaceNode, size_t>::Node {
public:
FreeSpaceNode(void* start, size_t sizeInBytes)
: m_start(start)
, m_sizeInBytes(sizeInBytes)
{
}
size_t key()
{
return m_sizeInBytes;
}
void* m_start;
size_t m_sizeInBytes;
};
typedef RedBlackTree<FreeSpaceNode, size_t> Tree;
void release(MetaAllocatorHandle*);
void* findAndRemoveFreeSpace(size_t sizeInBytes);
void addFreeSpaceFromReleasedHandle(void* start, size_t sizeInBytes);
void addFreeSpace(void* start, size_t sizeInBytes);
void incrementPageOccupancy(void* address, size_t sizeInBytes);
void decrementPageOccupancy(void* address, size_t sizeInBytes);
size_t roundUp(size_t sizeInBytes);
FreeSpaceNode* allocFreeSpaceNode();
WTF_EXPORT_PRIVATE void freeFreeSpaceNode(FreeSpaceNode*);
size_t m_allocationGranule;
unsigned m_logAllocationGranule;
size_t m_pageSize;
unsigned m_logPageSize;
Tree m_freeSpaceSizeMap;
HashMap<void*, FreeSpaceNode*> m_freeSpaceStartAddressMap;
HashMap<void*, FreeSpaceNode*> m_freeSpaceEndAddressMap;
HashMap<uintptr_t, size_t> m_pageOccupancyMap;
size_t m_bytesAllocated;
size_t m_bytesReserved;
size_t m_bytesCommitted;
Lock m_lock;
MetaAllocatorTracker* m_tracker;
#ifndef NDEBUG
size_t m_mallocBalance;
#endif
#if ENABLE(META_ALLOCATOR_PROFILE)
unsigned m_numAllocations;
unsigned m_numFrees;
#endif
};
}
#endif // WTF_MetaAllocator_h