#ifndef Cache_h
#define Cache_h
#include "Allocator.h"
#include "BExport.h"
#include "Deallocator.h"
#include "HeapKind.h"
#include "PerThread.h"
namespace bmalloc {
class Cache {
public:
static void* tryAllocate(HeapKind, size_t);
static void* allocate(HeapKind, size_t);
static void* tryAllocate(HeapKind, size_t alignment, size_t);
static void* allocate(HeapKind, size_t alignment, size_t);
static void deallocate(HeapKind, void*);
static void* reallocate(HeapKind, void*, size_t);
static void scavenge(HeapKind);
Cache(HeapKind);
Allocator& allocator() { return m_allocator; }
Deallocator& deallocator() { return m_deallocator; }
private:
BEXPORT static void* tryAllocateSlowCaseNullCache(HeapKind, size_t);
BEXPORT static void* allocateSlowCaseNullCache(HeapKind, size_t);
BEXPORT static void* allocateSlowCaseNullCache(HeapKind, size_t alignment, size_t);
BEXPORT static void deallocateSlowCaseNullCache(HeapKind, void*);
BEXPORT static void* reallocateSlowCaseNullCache(HeapKind, void*, size_t);
Deallocator m_deallocator;
Allocator m_allocator;
};
inline void* Cache::tryAllocate(HeapKind heapKind, size_t size)
{
PerHeapKind<Cache>* caches = PerThread<PerHeapKind<Cache>>::getFastCase();
if (!caches)
return tryAllocateSlowCaseNullCache(heapKind, size);
return caches->at(mapToActiveHeapKindAfterEnsuringGigacage(heapKind)).allocator().tryAllocate(size);
}
inline void* Cache::allocate(HeapKind heapKind, size_t size)
{
PerHeapKind<Cache>* caches = PerThread<PerHeapKind<Cache>>::getFastCase();
if (!caches)
return allocateSlowCaseNullCache(heapKind, size);
return caches->at(mapToActiveHeapKindAfterEnsuringGigacage(heapKind)).allocator().allocate(size);
}
inline void* Cache::tryAllocate(HeapKind heapKind, size_t alignment, size_t size)
{
PerHeapKind<Cache>* caches = PerThread<PerHeapKind<Cache>>::getFastCase();
if (!caches)
return allocateSlowCaseNullCache(heapKind, alignment, size);
return caches->at(mapToActiveHeapKindAfterEnsuringGigacage(heapKind)).allocator().tryAllocate(alignment, size);
}
inline void* Cache::allocate(HeapKind heapKind, size_t alignment, size_t size)
{
PerHeapKind<Cache>* caches = PerThread<PerHeapKind<Cache>>::getFastCase();
if (!caches)
return allocateSlowCaseNullCache(heapKind, alignment, size);
return caches->at(mapToActiveHeapKindAfterEnsuringGigacage(heapKind)).allocator().allocate(alignment, size);
}
inline void Cache::deallocate(HeapKind heapKind, void* object)
{
PerHeapKind<Cache>* caches = PerThread<PerHeapKind<Cache>>::getFastCase();
if (!caches)
return deallocateSlowCaseNullCache(heapKind, object);
return caches->at(mapToActiveHeapKindAfterEnsuringGigacage(heapKind)).deallocator().deallocate(object);
}
inline void* Cache::reallocate(HeapKind heapKind, void* object, size_t newSize)
{
PerHeapKind<Cache>* caches = PerThread<PerHeapKind<Cache>>::getFastCase();
if (!caches)
return reallocateSlowCaseNullCache(heapKind, object, newSize);
return caches->at(mapToActiveHeapKindAfterEnsuringGigacage(heapKind)).allocator().reallocate(object, newSize);
}
}
#endif // Cache_h