CopiedSpaceInlines.h [plain text]
#ifndef CopiedSpaceInlines_h
#define CopiedSpaceInlines_h
#include "CopiedBlock.h"
#include "CopiedSpace.h"
#include "Heap.h"
#include "HeapBlock.h"
#include "VM.h"
#include <wtf/CheckedBoolean.h>
namespace JSC {
inline bool CopiedSpace::contains(CopiedBlock* block)
{
return !m_blockFilter.ruleOut(reinterpret_cast<Bits>(block)) && m_blockSet.contains(block);
}
inline bool CopiedSpace::contains(void* ptr, CopiedBlock*& result)
{
CopiedBlock* block = blockFor(ptr);
if (contains(block)) {
result = block;
return true;
}
result = 0;
return false;
}
inline void CopiedSpace::pin(CopiedBlock* block)
{
block->pin();
}
inline void CopiedSpace::pinIfNecessary(void* opaquePointer)
{
EncodedJSValue* pointer = reinterpret_cast<EncodedJSValue*>(opaquePointer);
CopiedBlock* block;
if (contains(pointer, block))
pin(block);
pointer--;
pointer--;
if (contains(pointer, block))
pin(block);
}
inline void CopiedSpace::recycleEvacuatedBlock(CopiedBlock* block)
{
ASSERT(block);
ASSERT(block->canBeRecycled());
ASSERT(!block->m_isPinned);
{
SpinLockHolder locker(&m_toSpaceLock);
m_blockSet.remove(block);
m_fromSpace->remove(block);
}
m_heap->blockAllocator().deallocate(CopiedBlock::destroy(block));
}
inline void CopiedSpace::recycleBorrowedBlock(CopiedBlock* block)
{
m_heap->blockAllocator().deallocate(CopiedBlock::destroy(block));
{
MutexLocker locker(m_loanedBlocksLock);
ASSERT(m_numberOfLoanedBlocks > 0);
ASSERT(m_inCopyingPhase);
m_numberOfLoanedBlocks--;
if (!m_numberOfLoanedBlocks)
m_loanedBlocksCondition.signal();
}
}
inline CopiedBlock* CopiedSpace::allocateBlockForCopyingPhase()
{
ASSERT(m_inCopyingPhase);
CopiedBlock* block = CopiedBlock::createNoZeroFill(m_heap->blockAllocator().allocate<CopiedBlock>());
{
MutexLocker locker(m_loanedBlocksLock);
m_numberOfLoanedBlocks++;
}
ASSERT(!block->dataSize());
return block;
}
inline void CopiedSpace::allocateBlock()
{
if (m_heap->shouldCollect())
m_heap->collect(Heap::DoNotSweep);
m_allocator.resetCurrentBlock();
CopiedBlock* block = CopiedBlock::create(m_heap->blockAllocator().allocate<CopiedBlock>());
m_toSpace->push(block);
m_blockFilter.add(reinterpret_cast<Bits>(block));
m_blockSet.add(block);
m_allocator.setCurrentBlock(block);
}
inline CheckedBoolean CopiedSpace::tryAllocate(size_t bytes, void** outPtr)
{
ASSERT(!m_heap->vm()->isInitializingObject());
if (!m_allocator.tryAllocate(bytes, outPtr))
return tryAllocateSlowCase(bytes, outPtr);
ASSERT(*outPtr);
return true;
}
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::blockFor(void* ptr)
{
return reinterpret_cast<CopiedBlock*>(reinterpret_cast<size_t>(ptr) & s_blockMask);
}
}
#endif // CopiedSpaceInlines_h