LargeObject FreeList::take(Owner owner, size_t alignment, size_t size, size_t unalignedSize)
{
BASSERT(isPowerOfTwo(alignment));
size_t alignmentMask = alignment - 1;
LargeObject candidate;
size_t candidateIndex;
size_t begin = m_vector.size() > freeListSearchDepth ? m_vector.size() - freeListSearchDepth : 0;
for (size_t i = begin; i < m_vector.size(); ++i) {
LargeObject largeObject(LargeObject::DoNotValidate, m_vector[i].begin());
if (!largeObject.isValidAndFree(owner, m_vector[i].size())) {
m_vector.pop(i--);
continue;
}
if (largeObject.size() < size)
continue;
if (test(largeObject.begin(), alignmentMask) && largeObject.size() < unalignedSize)
continue;
if (!!candidate && candidate.begin() < largeObject.begin())
continue;
candidate = largeObject;
candidateIndex = i;
}
if (!!candidate)
m_vector.pop(candidateIndex);
return candidate;
}
void* Heap::allocateLarge(std::lock_guard<StaticMutex>& lock, size_t alignment, size_t size, size_t unalignedSize)
{
BASSERT(size <= largeMax);
BASSERT(size >= largeMin);
BASSERT(size == roundUpToMultipleOf<largeAlignment>(size));
BASSERT(unalignedSize <= largeMax);
BASSERT(unalignedSize >= largeMin);
BASSERT(unalignedSize == roundUpToMultipleOf<largeAlignment>(unalignedSize));
BASSERT(alignment <= largeChunkSize / 2);
BASSERT(alignment >= largeAlignment);
BASSERT(isPowerOfTwo(alignment));
LargeObject largeObject = m_largeObjects.take(alignment, size, unalignedSize);
if (!largeObject) {
m_isAllocatingPages = true;
largeObject = m_vmHeap.allocateLargeObject(alignment, size, unalignedSize);
}
size_t alignmentMask = alignment - 1;
if (test(largeObject.begin(), alignmentMask)) {
size_t prefixSize = roundUpToMultipleOf(alignment, largeObject.begin() + largeMin) - largeObject.begin();
std::pair<LargeObject, LargeObject> pair = largeObject.split(prefixSize);
m_largeObjects.insert(pair.first);
largeObject = pair.second;
}
return allocateLarge(lock, largeObject, size);
}
LargeObject FreeList::take(Owner owner, size_t size)
{
LargeObject candidate;
size_t candidateIndex;
size_t begin = m_vector.size() > freeListSearchDepth ? m_vector.size() - freeListSearchDepth : 0;
for (size_t i = begin; i < m_vector.size(); ++i) {
LargeObject largeObject(LargeObject::DoNotValidate, m_vector[i].begin());
if (!largeObject.isValidAndFree(owner, m_vector[i].size())) {
m_vector.pop(i--);
continue;
}
if (largeObject.size() < size)
continue;
if (!!candidate && candidate.begin() < largeObject.begin())
continue;
candidate = largeObject;
candidateIndex = i;
}
if (!!candidate)
m_vector.pop(candidateIndex);
return candidate;
}
void Heap::deallocateLarge(std::lock_guard<StaticMutex>&, const LargeObject& largeObject)
{
BASSERT(!largeObject.isFree());
largeObject.setFree(true);
LargeObject merged = largeObject.merge();
m_largeObjects.insert(merged);
m_scavenger.run();
}
