CopiedSpaceInlineMethods.h [plain text]
#ifndef CopiedSpaceInlineMethods_h
#define CopiedSpaceInlineMethods_h
#include "CopiedBlock.h"
#include "CopiedSpace.h"
#include "Heap.h"
#include "HeapBlock.h"
#include "JSGlobalData.h"
#include <wtf/CheckedBoolean.h>
namespace JSC {
inline bool CopiedSpace::contains(void* ptr, CopiedBlock*& result)
{
CopiedBlock* block = blockFor(ptr);
result = block;
return !m_toSpaceFilter.ruleOut(reinterpret_cast<Bits>(block)) && m_toSpaceSet.contains(block);
}
inline void CopiedSpace::pin(CopiedBlock* block)
{
block->m_isPinned = true;
}
inline void CopiedSpace::startedCopying()
{
DoublyLinkedList<HeapBlock>* temp = m_fromSpace;
m_fromSpace = m_toSpace;
m_toSpace = temp;
m_toSpaceFilter.reset();
m_allocator.startedCopying();
ASSERT(!m_inCopyingPhase);
ASSERT(!m_numberOfLoanedBlocks);
m_inCopyingPhase = true;
}
inline void CopiedSpace::recycleBlock(CopiedBlock* block)
{
m_heap->blockAllocator().deallocate(block);
{
MutexLocker locker(m_loanedBlocksLock);
ASSERT(m_numberOfLoanedBlocks > 0);
m_numberOfLoanedBlocks--;
if (!m_numberOfLoanedBlocks)
m_loanedBlocksCondition.signal();
}
}
inline CheckedBoolean CopiedSpace::borrowBlock(CopiedBlock** outBlock)
{
CopiedBlock* block = 0;
if (!getFreshBlock(AllocationMustSucceed, &block)) {
*outBlock = 0;
return false;
}
ASSERT(m_inCopyingPhase);
MutexLocker locker(m_loanedBlocksLock);
m_numberOfLoanedBlocks++;
ASSERT(block->m_offset == block->payload());
*outBlock = block;
return true;
}
inline CheckedBoolean CopiedSpace::addNewBlock()
{
CopiedBlock* block = 0;
if (!getFreshBlock(AllocationCanFail, &block))
return false;
m_toSpace->push(block);
m_toSpaceFilter.add(reinterpret_cast<Bits>(block));
m_toSpaceSet.add(block);
m_allocator.resetCurrentBlock(block);
return true;
}
inline CheckedBoolean CopiedSpace::allocateNewBlock(CopiedBlock** outBlock)
{
PageAllocationAligned allocation = PageAllocationAligned::allocate(HeapBlock::s_blockSize, HeapBlock::s_blockSize, OSAllocator::JSGCHeapPages);
if (!static_cast<bool>(allocation)) {
*outBlock = 0;
return false;
}
*outBlock = new (NotNull, allocation.base()) CopiedBlock(allocation);
return true;
}
inline bool CopiedSpace::fitsInBlock(CopiedBlock* block, size_t bytes)
{
return static_cast<char*>(block->m_offset) + bytes < reinterpret_cast<char*>(block) + block->capacity() && static_cast<char*>(block->m_offset) + bytes > block->m_offset;
}
inline CheckedBoolean CopiedSpace::tryAllocate(size_t bytes, void** outPtr)
{
ASSERT(!m_heap->globalData()->isInitializingObject());
if (isOversize(bytes) || !m_allocator.fitsInCurrentBlock(bytes))
return tryAllocateSlowCase(bytes, outPtr);
*outPtr = m_allocator.allocate(bytes);
ASSERT(*outPtr);
return true;
}
inline void* CopiedSpace::allocateFromBlock(CopiedBlock* block, size_t bytes)
{
ASSERT(fitsInBlock(block, bytes));
ASSERT(is8ByteAligned(block->m_offset));
void* ptr = block->m_offset;
ASSERT(block->m_offset >= block->payload() && block->m_offset < reinterpret_cast<char*>(block) + block->capacity());
block->m_offset = static_cast<void*>((static_cast<char*>(ptr) + bytes));
ASSERT(block->m_offset >= block->payload() && block->m_offset < reinterpret_cast<char*>(block) + block->capacity());
ASSERT(is8ByteAligned(ptr));
return ptr;
}
inline bool CopiedSpace::isOversize(size_t bytes)
{
return bytes > s_maxAllocationSize;
}
inline bool CopiedSpace::isPinned(void* ptr)
{
return blockFor(ptr)->m_isPinned;
}
inline CopiedBlock* CopiedSpace::oversizeBlockFor(void* ptr)
{
return reinterpret_cast<CopiedBlock*>(reinterpret_cast<size_t>(ptr) & WTF::pageMask());
}
inline CopiedBlock* CopiedSpace::blockFor(void* ptr)
{
return reinterpret_cast<CopiedBlock*>(reinterpret_cast<size_t>(ptr) & s_blockMask);
}
}
#endif