Changeset 108107 in webkit for trunk/Source/JavaScriptCore/heap/MarkStack.cpp

Timestamp:

Feb 17, 2012, 12:09:14 PM (13 years ago)

Author:

[email protected]

Message:

Rename Bump* to Copy*
​https://bugs.webkit.org/show_bug.cgi?id=78573

Reviewed by Geoffrey Garen.

Renamed anything with "Bump" in the name to have "Copied" instead.

• CMakeLists.txt:
• GNUmakefile.list.am:
• JavaScriptCore.gypi:
• JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
• JavaScriptCore.xcodeproj/project.pbxproj:
• Target.pri:
• heap/BumpBlock.h: Removed.
• heap/BumpSpace.cpp: Removed.
• heap/BumpSpace.h: Removed.
• heap/BumpSpaceInlineMethods.h: Removed.
• heap/ConservativeRoots.cpp:

(JSC::ConservativeRoots::ConservativeRoots):
(JSC::ConservativeRoots::genericAddPointer):

• heap/ConservativeRoots.h:

(ConservativeRoots):

• heap/CopiedBlock.h: Added.

(JSC):
(CopiedBlock):
(JSC::CopiedBlock::CopiedBlock):

• heap/CopiedSpace.cpp: Added.

(JSC):
(JSC::CopiedSpace::tryAllocateSlowCase):

• heap/CopiedSpace.h: Added.

(JSC):
(CopiedSpace):
(JSC::CopiedSpace::isInCopyPhase):
(JSC::CopiedSpace::totalMemoryAllocated):
(JSC::CopiedSpace::totalMemoryUtilized):

• heap/CopiedSpaceInlineMethods.h: Added.

(JSC):
(JSC::CopiedSpace::CopiedSpace):
(JSC::CopiedSpace::init):
(JSC::CopiedSpace::contains):
(JSC::CopiedSpace::pin):
(JSC::CopiedSpace::startedCopying):
(JSC::CopiedSpace::doneCopying):
(JSC::CopiedSpace::doneFillingBlock):
(JSC::CopiedSpace::recycleBlock):
(JSC::CopiedSpace::getFreshBlock):
(JSC::CopiedSpace::borrowBlock):
(JSC::CopiedSpace::addNewBlock):
(JSC::CopiedSpace::allocateNewBlock):
(JSC::CopiedSpace::fitsInBlock):
(JSC::CopiedSpace::fitsInCurrentBlock):
(JSC::CopiedSpace::tryAllocate):
(JSC::CopiedSpace::tryAllocateOversize):
(JSC::CopiedSpace::allocateFromBlock):
(JSC::CopiedSpace::tryReallocate):
(JSC::CopiedSpace::tryReallocateOversize):
(JSC::CopiedSpace::isOversize):
(JSC::CopiedSpace::isPinned):
(JSC::CopiedSpace::oversizeBlockFor):
(JSC::CopiedSpace::blockFor):

• heap/Heap.cpp:
• heap/Heap.h:

(JSC):
(Heap):

• heap/MarkStack.cpp:

(JSC::MarkStackThreadSharedData::MarkStackThreadSharedData):
(JSC::SlotVisitor::drainFromShared):
(JSC::SlotVisitor::startCopying):
(JSC::SlotVisitor::allocateNewSpace):
(JSC::SlotVisitor::doneCopying):

• heap/MarkStack.h:

(MarkStackThreadSharedData):

• heap/SlotVisitor.h:

(SlotVisitor):

• runtime/JSArray.cpp:
• runtime/JSObject.cpp:

File:

• trunk/Source/JavaScriptCore/heap/MarkStack.cpp (modified) (7 diffs)

trunk/Source/JavaScriptCore/heap/MarkStack.cpp

@@ -27 +27 @@
 #include "MarkStack.h"
 
-#include "BumpSpace.h"
-#include "BumpSpaceInlineMethods.h"
+#include "CopiedSpace.h"
+#include "CopiedSpaceInlineMethods.h"
 #include "ConservativeRoots.h"
 #include "Heap.h"
@@ -236 +236 @@
 MarkStackThreadSharedData::MarkStackThreadSharedData(JSGlobalData* globalData)
     : m_globalData(globalData)
-    , m_bumpSpace(&globalData->heap.m_storageSpace)
+    , m_copiedSpace(&globalData->heap.m_storageSpace)
     , m_sharedMarkStack(m_segmentAllocator)
     , m_numberOfActiveParallelMarkers(0)
@@ -403 +403 @@
                     // Did we reach termination?
                     if (!m_shared.m_numberOfActiveParallelMarkers && m_shared.m_sharedMarkStack.isEmpty()) {
-                        // Let any sleeping slaves know it's time for them to give their private BumpBlocks back
+                        // Let any sleeping slaves know it's time for them to give their private CopiedBlocks back
                         m_shared.m_markingCondition.broadcast();
                         return;
@@ -460 +460 @@
 {
     ASSERT(!m_copyBlock);
-    if (!m_shared.m_bumpSpace->borrowBlock(&m_copyBlock))
+    if (!m_shared.m_copiedSpace->borrowBlock(&m_copyBlock))
         CRASH();
 }    
@@ -466 +466 @@
 void* SlotVisitor::allocateNewSpace(void* ptr, size_t bytes)
 {
-    if (BumpSpace::isOversize(bytes)) {
-        m_shared.m_bumpSpace->pin(BumpSpace::oversizeBlockFor(ptr));
+    if (CopiedSpace::isOversize(bytes)) {
+        m_shared.m_copiedSpace->pin(CopiedSpace::oversizeBlockFor(ptr));
         return 0;
     }
 
-    if (m_shared.m_bumpSpace->isPinned(ptr))
+    if (m_shared.m_copiedSpace->isPinned(ptr))
         return 0;
 
@@ -478 +478 @@
         startCopying();
 
-    if (!BumpSpace::fitsInBlock(m_copyBlock, bytes)) {
+    if (!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_bumpSpace->doneFillingBlock(m_copyBlock);
-        if (!m_shared.m_bumpSpace->borrowBlock(&m_copyBlock))
+        m_shared.m_copiedSpace->doneFillingBlock(m_copyBlock);
+        if (!m_shared.m_copiedSpace->borrowBlock(&m_copyBlock))
             CRASH();
     }
-    return BumpSpace::allocateFromBlock(m_copyBlock, bytes);
+    return CopiedSpace::allocateFromBlock(m_copyBlock, bytes);
 }
 
@@ -525 +525 @@
         return;
 
-    m_shared.m_bumpSpace->doneFillingBlock(m_copyBlock);
+    m_shared.m_copiedSpace->doneFillingBlock(m_copyBlock);
 
     m_copyBlock = 0;