1 files changed, 25 insertions, 22 deletions

diff --git a/Source/JavaScriptCore/heap/CopiedSpace.cpp b/Source/JavaScriptCore/heap/CopiedSpace.cpp
index 47656ed15..eb294214f 100644
--- a/Source/JavaScriptCore/heap/CopiedSpace.cpp
+++ b/Source/JavaScriptCore/heap/CopiedSpace.cpp
@@ -28,7 +28,8 @@
 
 #include "CopiedSpaceInlines.h"
 #include "GCActivityCallback.h"
-#include "JSCInlines.h"
+#include "Operations.h"
+#include "Options.h"
 
 namespace JSC {
 
@@ -37,29 +38,29 @@ CopiedSpace::CopiedSpace(Heap* heap)
     , m_inCopyingPhase(false)
     , m_shouldDoCopyPhase(false)
     , m_numberOfLoanedBlocks(0)
-    , m_bytesRemovedFromOldSpaceDueToReallocation(0)
 {
+    m_toSpaceLock.Init();
 }
 
 CopiedSpace::~CopiedSpace()
 {
     while (!m_oldGen.toSpace->isEmpty())
-        CopiedBlock::destroy(*heap(), m_oldGen.toSpace->removeHead());
+        m_heap->blockAllocator().deallocate(CopiedBlock::destroy(m_oldGen.toSpace->removeHead()));
 
     while (!m_oldGen.fromSpace->isEmpty())
-        CopiedBlock::destroy(*heap(), m_oldGen.fromSpace->removeHead());
+        m_heap->blockAllocator().deallocate(CopiedBlock::destroy(m_oldGen.fromSpace->removeHead()));
 
     while (!m_oldGen.oversizeBlocks.isEmpty())
-        CopiedBlock::destroy(*heap(), m_oldGen.oversizeBlocks.removeHead());
+        m_heap->blockAllocator().deallocateCustomSize(CopiedBlock::destroy(m_oldGen.oversizeBlocks.removeHead()));
 
     while (!m_newGen.toSpace->isEmpty())
-        CopiedBlock::destroy(*heap(), m_newGen.toSpace->removeHead());
+        m_heap->blockAllocator().deallocate(CopiedBlock::destroy(m_newGen.toSpace->removeHead()));
 
     while (!m_newGen.fromSpace->isEmpty())
-        CopiedBlock::destroy(*heap(), m_newGen.fromSpace->removeHead());
+        m_heap->blockAllocator().deallocate(CopiedBlock::destroy(m_newGen.fromSpace->removeHead()));
 
     while (!m_newGen.oversizeBlocks.isEmpty())
-        CopiedBlock::destroy(*heap(), m_newGen.oversizeBlocks.removeHead());
+        m_heap->blockAllocator().deallocateCustomSize(CopiedBlock::destroy(m_newGen.oversizeBlocks.removeHead()));
 
     ASSERT(m_oldGen.toSpace->isEmpty());
     ASSERT(m_oldGen.fromSpace->isEmpty());
@@ -98,7 +99,7 @@ CheckedBoolean CopiedSpace::tryAllocateOversize(size_t bytes, void** outPtr)
 {
     ASSERT(isOversize(bytes));
     
-    CopiedBlock* block = CopiedBlock::create(*m_heap, WTF::roundUpToMultipleOf<sizeof(double)>(sizeof(CopiedBlock) + bytes));
+    CopiedBlock* block = CopiedBlock::create(m_heap->blockAllocator().allocateCustomSize(sizeof(CopiedBlock) + bytes, CopiedBlock::blockSize));
     m_newGen.oversizeBlocks.push(block);
     m_newGen.blockFilter.add(reinterpret_cast<Bits>(block));
     m_blockSet.add(block);
@@ -109,7 +110,7 @@ CheckedBoolean CopiedSpace::tryAllocateOversize(size_t bytes, void** outPtr)
     *outPtr = allocator.forceAllocate(bytes);
     allocator.resetCurrentBlock();
 
-    m_heap->didAllocate(block->capacity());
+    m_heap->didAllocate(block->region()->blockSize());
 
     return true;
 }
@@ -155,16 +156,12 @@ CheckedBoolean CopiedSpace::tryReallocateOversize(void** ptr, size_t oldSize, si
 
     CopiedBlock* oldBlock = CopiedSpace::blockFor(oldPtr);
     if (oldBlock->isOversize()) {
-        // FIXME: Eagerly deallocating the old space block probably buys more confusion than
-        // value.
-        // https://bugs.webkit.org/show_bug.cgi?id=144750
-        if (oldBlock->isOld()) {
-            m_bytesRemovedFromOldSpaceDueToReallocation += oldBlock->size();
+        if (oldBlock->isOld())
             m_oldGen.oversizeBlocks.remove(oldBlock);
-        } else
+        else
             m_newGen.oversizeBlocks.remove(oldBlock);
         m_blockSet.remove(oldBlock);
-        CopiedBlock::destroy(*heap(), oldBlock);
+        m_heap->blockAllocator().deallocateCustomSize(CopiedBlock::destroy(oldBlock));
     }
     
     *ptr = newPtr;
@@ -190,17 +187,19 @@ void CopiedSpace::doneFillingBlock(CopiedBlock* block, CopiedBlock** exchange)
 
     {
         // Always put the block into the old gen because it's being promoted!
-        LockHolder locker(&m_toSpaceLock);
+        SpinLockHolder locker(&m_toSpaceLock);
         m_oldGen.toSpace->push(block);
         m_blockSet.add(block);
         m_oldGen.blockFilter.add(reinterpret_cast<Bits>(block));
     }
 
     {
-        LockHolder locker(m_loanedBlocksLock);
+        MutexLocker locker(m_loanedBlocksLock);
         ASSERT(m_numberOfLoanedBlocks > 0);
         ASSERT(m_inCopyingPhase);
         m_numberOfLoanedBlocks--;
+        if (!m_numberOfLoanedBlocks)
+            m_loanedBlocksCondition.signal();
     }
 }
 
@@ -227,8 +226,13 @@ void CopiedSpace::didStartFullCollection()
 
 void CopiedSpace::doneCopying()
 {
-    RELEASE_ASSERT(!m_numberOfLoanedBlocks);
-    RELEASE_ASSERT(m_inCopyingPhase == m_shouldDoCopyPhase);
+    {
+        MutexLocker locker(m_loanedBlocksLock);
+        while (m_numberOfLoanedBlocks > 0)
+            m_loanedBlocksCondition.wait(m_loanedBlocksLock);
+    }
+
+    ASSERT(m_inCopyingPhase == m_shouldDoCopyPhase);
     m_inCopyingPhase = false;
 
     DoublyLinkedList<CopiedBlock>* toSpace;
@@ -249,7 +253,6 @@ void CopiedSpace::doneCopying()
         // We don't add the block to the blockSet because it was never removed.
         ASSERT(m_blockSet.contains(block));
         blockFilter->add(reinterpret_cast<Bits>(block));
-        block->didSurviveGC();
         toSpace->push(block);
     }