diff -rp -u8 webkit-orig/Source/JavaScriptCore/heap/CopiedSpace.h webkit-1.8.1/Source/JavaScriptCore/heap/CopiedSpace.h --- webkit-orig/Source/JavaScriptCore/heap/CopiedSpace.h 2012-12-01 19:36:43.309097015 +0100 +++ webkit-1.8.1/Source/JavaScriptCore/heap/CopiedSpace.h 2012-12-01 19:43:23.901115496 +0100 @@ -59,36 +59,36 @@ public: void pin(CopiedBlock*); bool isPinned(void*); bool contains(void*, CopiedBlock*&); size_t totalMemoryAllocated() { return m_totalMemoryAllocated; } size_t totalMemoryUtilized() { return m_totalMemoryUtilized; } - static CopiedBlock* blockFor(void*); + CopiedBlock* blockFor(void*); private: CheckedBoolean tryAllocateSlowCase(size_t, void**); CheckedBoolean addNewBlock(); CheckedBoolean allocateNewBlock(CopiedBlock**); bool fitsInCurrentBlock(size_t); - static void* allocateFromBlock(CopiedBlock*, size_t); + void* allocateFromBlock(CopiedBlock*, size_t); CheckedBoolean tryAllocateOversize(size_t, void**); CheckedBoolean tryReallocateOversize(void**, size_t, size_t); - static bool isOversize(size_t); + bool isOversize(size_t); CheckedBoolean borrowBlock(CopiedBlock**); CheckedBoolean getFreshBlock(AllocationEffort, CopiedBlock**); void doneFillingBlock(CopiedBlock*); void recycleBlock(CopiedBlock*); - static bool fitsInBlock(CopiedBlock*, size_t); - static CopiedBlock* oversizeBlockFor(void* ptr); + bool fitsInBlock(CopiedBlock*, size_t); + CopiedBlock* oversizeBlockFor(void* ptr); Heap* m_heap; CopiedBlock* m_currentBlock; TinyBloomFilter m_toSpaceFilter; TinyBloomFilter m_oversizeFilter; HashSet m_toSpaceSet; @@ -107,19 +107,19 @@ private: size_t m_totalMemoryUtilized; bool m_inCopyingPhase; Mutex m_loanedBlocksLock; ThreadCondition m_loanedBlocksCondition; size_t m_numberOfLoanedBlocks; - static const size_t s_blockSize = 64 * KB; - static const size_t s_maxAllocationSize = 32 * KB; - static const size_t s_pageSize = 4 * KB; - static const size_t s_pageMask = ~(s_pageSize - 1); + size_t m_pageSize; + size_t m_pageMask; + size_t m_maxAllocationSize; + size_t m_blockSize; + size_t m_blockMask; static const size_t s_initialBlockNum = 16; - static const size_t s_blockMask = ~(s_blockSize - 1); }; } // namespace JSC #endif diff -rp -u8 webkit-orig/Source/JavaScriptCore/heap/CopiedSpaceInlineMethods.h webkit-1.8.1/Source/JavaScriptCore/heap/CopiedSpaceInlineMethods.h --- webkit-orig/Source/JavaScriptCore/heap/CopiedSpaceInlineMethods.h 2012-12-01 19:36:43.309097015 +0100 +++ webkit-1.8.1/Source/JavaScriptCore/heap/CopiedSpaceInlineMethods.h 2012-12-01 19:43:40.389116255 +0100 @@ -27,37 +27,53 @@ #define CopiedSpaceInlineMethods_h #include "CopiedBlock.h" #include "CopiedSpace.h" #include "Heap.h" #include "HeapBlock.h" #include "JSGlobalData.h" #include +#include namespace JSC { inline CopiedSpace::CopiedSpace(Heap* heap) : m_heap(heap) , m_currentBlock(0) , m_toSpace(0) , m_fromSpace(0) , m_totalMemoryAllocated(0) , m_totalMemoryUtilized(0) , m_inCopyingPhase(false) , m_numberOfLoanedBlocks(0) + , m_pageSize(0) + , m_pageMask(0) + , m_maxAllocationSize(0) + , m_blockSize(0) + , m_blockMask(0) { } inline void CopiedSpace::init() { + m_pageSize = WTF::pageSize(); + m_pageMask = ~(m_pageSize - 1); + m_maxAllocationSize = 32 * KB; + if (m_maxAllocationSize < m_pageSize) + m_maxAllocationSize = m_pageSize; + m_blockSize = 64 * KB; + if (m_blockSize < m_pageSize) + m_blockSize = m_pageSize; + m_blockMask = ~(m_blockSize - 1); + m_toSpace = &m_blocks1; m_fromSpace = &m_blocks2; - m_totalMemoryAllocated += s_blockSize * s_initialBlockNum; + m_totalMemoryAllocated += m_blockSize * s_initialBlockNum; if (!addNewBlock()) CRASH(); } inline bool CopiedSpace::contains(void* ptr, CopiedBlock*& result) { CopiedBlock* block = blockFor(ptr); @@ -127,17 +143,17 @@ inline void CopiedSpace::doneCopying() if (!(m_currentBlock = static_cast(m_toSpace->head()))) if (!addNewBlock()) CRASH(); } inline void CopiedSpace::doneFillingBlock(CopiedBlock* block) { ASSERT(block); - ASSERT(block->m_offset < reinterpret_cast(block) + s_blockSize); + ASSERT(block->m_offset < reinterpret_cast(block) + m_blockSize); ASSERT(m_inCopyingPhase); if (block->m_offset == block->m_payload) { recycleBlock(block); return; } { @@ -239,34 +255,34 @@ inline CheckedBoolean CopiedSpace::addNe m_toSpace->push(block); m_currentBlock = block; return true; } inline CheckedBoolean CopiedSpace::allocateNewBlock(CopiedBlock** outBlock) { - PageAllocationAligned allocation = PageAllocationAligned::allocate(s_blockSize, s_blockSize, OSAllocator::JSGCHeapPages); + PageAllocationAligned allocation = PageAllocationAligned::allocate(m_blockSize, m_blockSize, OSAllocator::JSGCHeapPages); if (!static_cast(allocation)) { *outBlock = 0; return false; } { MutexLocker locker(m_memoryStatsLock); - m_totalMemoryAllocated += s_blockSize; + m_totalMemoryAllocated += m_blockSize; } *outBlock = new (NotNull, allocation.base()) CopiedBlock(allocation); return true; } inline bool CopiedSpace::fitsInBlock(CopiedBlock* block, size_t bytes) { - return static_cast(block->m_offset) + bytes < reinterpret_cast(block) + s_blockSize && static_cast(block->m_offset) + bytes > block->m_offset; + return static_cast(block->m_offset) + bytes < reinterpret_cast(block) + m_blockSize && static_cast(block->m_offset) + bytes > block->m_offset; } inline bool CopiedSpace::fitsInCurrentBlock(size_t bytes) { return fitsInBlock(m_currentBlock, bytes); } inline CheckedBoolean CopiedSpace::tryAllocate(size_t bytes, void** outPtr) @@ -279,18 +295,18 @@ inline CheckedBoolean CopiedSpace::tryAl *outPtr = allocateFromBlock(m_currentBlock, bytes); return true; } inline CheckedBoolean CopiedSpace::tryAllocateOversize(size_t bytes, void** outPtr) { ASSERT(isOversize(bytes)); - size_t blockSize = WTF::roundUpToMultipleOf(sizeof(CopiedBlock) + bytes); - PageAllocationAligned allocation = PageAllocationAligned::allocate(blockSize, s_pageSize, OSAllocator::JSGCHeapPages); + size_t blockSize = (sizeof(CopiedBlock) + bytes + (m_pageSize - 1)) & m_pageMask; + PageAllocationAligned allocation = PageAllocationAligned::allocate(blockSize, m_pageSize, OSAllocator::JSGCHeapPages); if (!static_cast(allocation)) { *outPtr = 0; return false; } CopiedBlock* block = new (NotNull, allocation.base()) CopiedBlock(allocation); m_oversizeBlocks.push(block); ASSERT(isPointerAligned(block->m_offset)); @@ -305,36 +321,36 @@ inline CheckedBoolean CopiedSpace::tryAl inline void* CopiedSpace::allocateFromBlock(CopiedBlock* block, size_t bytes) { ASSERT(!isOversize(bytes)); ASSERT(fitsInBlock(block, bytes)); ASSERT(isPointerAligned(block->m_offset)); void* ptr = block->m_offset; - ASSERT(block->m_offset >= block->m_payload && block->m_offset < reinterpret_cast(block) + s_blockSize); + ASSERT(block->m_offset >= block->m_payload && block->m_offset < reinterpret_cast(block) + m_blockSize); block->m_offset = static_cast((static_cast(ptr) + bytes)); - ASSERT(block->m_offset >= block->m_payload && block->m_offset < reinterpret_cast(block) + s_blockSize); + ASSERT(block->m_offset >= block->m_payload && block->m_offset < reinterpret_cast(block) + m_blockSize); ASSERT(isPointerAligned(ptr)); return ptr; } inline CheckedBoolean CopiedSpace::tryReallocate(void** ptr, size_t oldSize, size_t newSize) { if (oldSize >= newSize) return true; void* oldPtr = *ptr; ASSERT(!m_heap->globalData()->isInitializingObject()); if (isOversize(oldSize) || isOversize(newSize)) return tryReallocateOversize(ptr, oldSize, newSize); - if (static_cast(oldPtr) + oldSize == m_currentBlock->m_offset && oldPtr > m_currentBlock && oldPtr < reinterpret_cast(m_currentBlock) + s_blockSize) { + if (static_cast(oldPtr) + oldSize == m_currentBlock->m_offset && oldPtr > m_currentBlock && oldPtr < reinterpret_cast(m_currentBlock) + m_blockSize) { m_currentBlock->m_offset = oldPtr; if (fitsInCurrentBlock(newSize)) { m_totalMemoryUtilized += newSize - oldSize; return allocateFromBlock(m_currentBlock, newSize); } } m_totalMemoryUtilized -= oldSize; @@ -372,29 +388,29 @@ inline CheckedBoolean CopiedSpace::tryRe m_totalMemoryUtilized -= oldSize; *ptr = newPtr; return true; } inline bool CopiedSpace::isOversize(size_t bytes) { - return bytes > s_maxAllocationSize; + return bytes > m_maxAllocationSize; } inline bool CopiedSpace::isPinned(void* ptr) { return blockFor(ptr)->m_isPinned; } inline CopiedBlock* CopiedSpace::oversizeBlockFor(void* ptr) { - return reinterpret_cast(reinterpret_cast(ptr) & s_pageMask); + return reinterpret_cast(reinterpret_cast(ptr) & m_pageMask); } inline CopiedBlock* CopiedSpace::blockFor(void* ptr) { - return reinterpret_cast(reinterpret_cast(ptr) & s_blockMask); + return reinterpret_cast(reinterpret_cast(ptr) & m_blockMask); } } // namespace JSC #endif diff -rp -u8 webkit-orig/Source/JavaScriptCore/heap/MarkStack.cpp webkit-1.8.1/Source/JavaScriptCore/heap/MarkStack.cpp --- webkit-orig/Source/JavaScriptCore/heap/MarkStack.cpp 2012-12-01 19:36:43.309097015 +0100 +++ webkit-1.8.1/Source/JavaScriptCore/heap/MarkStack.cpp 2012-12-01 19:44:00.381117177 +0100 @@ -459,36 +459,36 @@ void SlotVisitor::startCopying() { ASSERT(!m_copyBlock); if (!m_shared.m_copiedSpace->borrowBlock(&m_copyBlock)) CRASH(); } void* SlotVisitor::allocateNewSpace(void* ptr, size_t bytes) { - if (CopiedSpace::isOversize(bytes)) { - m_shared.m_copiedSpace->pin(CopiedSpace::oversizeBlockFor(ptr)); + if (m_shared.m_copiedSpace->isOversize(bytes)) { + m_shared.m_copiedSpace->pin(m_shared.m_copiedSpace->oversizeBlockFor(ptr)); return 0; } if (m_shared.m_copiedSpace->isPinned(ptr)) return 0; // The only time it's possible to have a null copy block is if we have just started copying. if (!m_copyBlock) startCopying(); - if (!CopiedSpace::fitsInBlock(m_copyBlock, bytes)) { + if (!m_shared.m_copiedSpace->fitsInBlock(m_copyBlock, bytes)) { // We don't need to lock across these two calls because the master thread won't // call doneCopying() because this thread is considered active. m_shared.m_copiedSpace->doneFillingBlock(m_copyBlock); if (!m_shared.m_copiedSpace->borrowBlock(&m_copyBlock)) CRASH(); } - return CopiedSpace::allocateFromBlock(m_copyBlock, bytes); + return m_shared.m_copiedSpace->allocateFromBlock(m_copyBlock, bytes); } void SlotVisitor::copy(void** ptr, size_t bytes) { void* newPtr = 0; if (!(newPtr = allocateNewSpace(*ptr, bytes))) return; Signed-off-by: Stephan Schreiber