Changeset 108107 in webkit for trunk/Source/JavaScriptCore/heap

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:

Location:

trunk/Source/JavaScriptCore/heap

Files:

• BumpBlock.h (deleted)
• BumpSpace.cpp (deleted)
• BumpSpace.h (deleted)
• BumpSpaceInlineMethods.h (deleted)
• ConservativeRoots.cpp (modified) (3 diffs)
• ConservativeRoots.h (modified) (2 diffs)
• CopiedBlock.h (added)
• CopiedSpace.cpp (added)
• CopiedSpace.h (added)
• CopiedSpaceInlineMethods.h (added)
• Heap.cpp (modified) (1 diff)
• Heap.h (modified) (3 diffs)
• MarkStack.cpp (modified) (7 diffs)
• MarkStack.h (modified) (2 diffs)
• SlotVisitor.h (modified) (2 diffs)

trunk/Source/JavaScriptCore/heap/ConservativeRoots.cpp

@@ -27 +27 @@
 #include "ConservativeRoots.h"
 
-#include "BumpSpace.h"
-#include "BumpSpaceInlineMethods.h"
+#include "CopiedSpace.h"
+#include "CopiedSpaceInlineMethods.h"
 #include "CodeBlock.h"
 #include "DFGCodeBlocks.h"
@@ -37 +37 @@
 namespace JSC {
 
-ConservativeRoots::ConservativeRoots(const MarkedBlockSet* blocks, BumpSpace* bumpSpace)
+ConservativeRoots::ConservativeRoots(const MarkedBlockSet* blocks, CopiedSpace* copiedSpace)
     : m_roots(m_inlineRoots)
     , m_size(0)
     , m_capacity(inlineCapacity)
     , m_blocks(blocks)
-    , m_bumpSpace(bumpSpace)
+    , m_copiedSpace(copiedSpace)
 {
 }
@@ -73 +73 @@
     markHook.mark(p);
     
-    BumpBlock* block;
-    if (m_bumpSpace->contains(p, block))
-        m_bumpSpace->pin(block);
+    CopiedBlock* block;
+    if (m_copiedSpace->contains(p, block))
+        m_copiedSpace->pin(block);
     
     MarkedBlock* candidate = MarkedBlock::blockFor(p);

trunk/Source/JavaScriptCore/heap/ConservativeRoots.h

@@ -39 +39 @@
 class ConservativeRoots {
 public:
-    ConservativeRoots(const MarkedBlockSet*, BumpSpace*);
+    ConservativeRoots(const MarkedBlockSet*, CopiedSpace*);
     ~ConservativeRoots();
 
@@ -64 +64 @@
     size_t m_capacity;
     const MarkedBlockSet* m_blocks;
-    BumpSpace* m_bumpSpace;
+    CopiedSpace* m_copiedSpace;
     JSCell* m_inlineRoots[inlineCapacity];
 };

trunk/Source/JavaScriptCore/heap/Heap.cpp

@@ -22 +22 @@
 #include "Heap.h"
 
-#include "BumpSpace.h"
-#include "BumpSpaceInlineMethods.h"
+#include "CopiedSpace.h"
+#include "CopiedSpaceInlineMethods.h"
 #include "CodeBlock.h"
 #include "ConservativeRoots.h"

trunk/Source/JavaScriptCore/heap/Heap.h

@@ -41 +41 @@
 namespace JSC {
 
-    class BumpSpace;
+    class CopiedSpace;
     class CodeBlock;
     class GCActivityCallback;
@@ -140 +140 @@
         friend class MarkedAllocator;
         friend class MarkedBlock;
-        friend class BumpSpace;
+        friend class CopiedSpace;
         friend class SlotVisitor;
         friend class CodeBlock;
@@ -198 +198 @@
         OperationInProgress m_operationInProgress;
         MarkedSpace m_objectSpace;
-        BumpSpace m_storageSpace;
+        CopiedSpace m_storageSpace;
 
         DoublyLinkedList<HeapBlock> m_freeBlocks;

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;

trunk/Source/JavaScriptCore/heap/MarkStack.h

@@ -27 +27 @@
 #define MarkStack_h
 
-#include "BumpSpace.h"
+#include "CopiedSpace.h"
 #include "HandleTypes.h"
 #include "Options.h"
@@ -183 +183 @@
 
         JSGlobalData* m_globalData;
-        BumpSpace* m_bumpSpace;
+        CopiedSpace* m_copiedSpace;
         
         MarkStackSegmentAllocator m_segmentAllocator;

trunk/Source/JavaScriptCore/heap/SlotVisitor.h

@@ -27 +27 @@
 #define SlotVisitor_h
 
-#include "BumpSpace.h"
+#include "CopiedSpace.h"
 #include "MarkStack.h"
 
@@ -79 +79 @@
     }
     
-    BumpBlock* m_copyBlock;
+    CopiedBlock* m_copyBlock;
 };