PODFreeListArena.h [plain text]
#ifndef PODFreeListArena_h
#define PODFreeListArena_h
#include "PODArena.h"
namespace WebCore {
template <class T>
class PODFreeListArena : public PODArena {
public:
static PassRefPtr<PODFreeListArena> create()
{
return adoptRef(new PODFreeListArena);
}
template<class Argument1Type> T* allocateObject(const Argument1Type& argument1)
{
#if defined(ADDRESS_SANITIZER)
return new T(argument1);
#else
size_t roundedSize = roundUp(sizeof(T), minAlignment<T>());
void* ptr = allocate(roundedSize);
if (ptr) {
new(ptr) T(argument1);
}
return static_cast<T*>(ptr);
#endif
}
void freeObject(T* ptr)
{
#if defined(ADDRESS_SANITIZER)
delete ptr;
#else
for (typename Vector<OwnPtr<FreeListChunk>>::const_iterator it = m_chunks.begin(), end = m_chunks.end(); it != end; ++it) {
FreeListChunk* chunk = static_cast<FreeListChunk*>(it->get());
if (chunk->contains(ptr))
chunk->free(ptr);
}
#endif
}
private:
enum {
DefaultChunkSize = 16384
};
PODFreeListArena()
: m_current(0)
, m_currentChunkSize(DefaultChunkSize)
{
}
void* allocate(size_t size)
{
void* ptr = 0;
if (m_current) {
ptr = m_current->allocate(size);
if (!ptr) {
for (typename Vector<OwnPtr<FreeListChunk>>::const_iterator it = m_chunks.begin(), end = m_chunks.end(); it != end; ++it) {
FreeListChunk* chunk = static_cast<FreeListChunk*>(it->get());
if (chunk->hasFreeList()) {
ptr = chunk->allocate(size);
if (ptr)
break;
}
}
}
}
if (!ptr) {
if (size > m_currentChunkSize)
m_currentChunkSize = size;
m_chunks.append(adoptPtr(new FreeListChunk(m_currentChunkSize)));
m_current = m_chunks.last().get();
ptr = m_current->allocate(size);
}
return ptr;
}
class FreeListChunk {
WTF_MAKE_NONCOPYABLE(FreeListChunk);
struct FreeCell {
FreeCell *m_next;
};
public:
explicit FreeListChunk(size_t size)
: m_size(size)
, m_currentOffset(0)
, m_freeList(0)
{
m_base = static_cast<uint8_t*>(fastMalloc(size));
}
~FreeListChunk()
{
fastFree(m_base);
}
void* allocate(size_t size)
{
if (m_freeList) {
void *cell = m_freeList;
m_freeList = m_freeList->m_next;
return cell;
}
if (m_currentOffset + size < m_currentOffset)
return 0;
if (m_currentOffset + size > m_size)
return 0;
void* result = m_base + m_currentOffset;
m_currentOffset += size;
return result;
}
void free(void* ptr)
{
ASSERT(contains(ptr));
FreeCell* cell = reinterpret_cast<FreeCell*>(ptr);
cell->m_next = m_freeList;
m_freeList = cell;
}
bool contains(void* ptr) const
{
return ptr >= m_base && ptr < m_base + m_size;
}
bool hasFreeList() const
{
return m_freeList;
}
private:
uint8_t* m_base;
size_t m_size;
size_t m_currentOffset;
FreeCell *m_freeList;
};
FreeListChunk* m_current;
size_t m_currentChunkSize;
Vector<OwnPtr<FreeListChunk>> m_chunks;
};
}
#endif