Changeset 106676 in webkit
- Timestamp:
- Feb 3, 2012 11:21:28 AM (12 years ago)
- Location:
- trunk/Source/JavaScriptCore
- Files:
-
- 13 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/Source/JavaScriptCore/CMakeLists.txt
r106197 r106676 81 81 heap/HandleStack.cpp 82 82 heap/MachineStackMarker.cpp 83 heap/MarkedAllocator.cpp 83 84 heap/MarkedBlock.cpp 84 85 heap/MarkedSpace.cpp -
trunk/Source/JavaScriptCore/ChangeLog
r106650 r106676 1 2012-02-03 Mark Hahnenberg <mhahnenberg@apple.com> 2 3 Refactor MarkedBlock::SizeClass into a separate class 4 https://bugs.webkit.org/show_bug.cgi?id=77600 5 6 Reviewed by Geoffrey Garen. 7 8 We pulled SizeClass out into its own class, named MarkedAllocator, and gave it 9 the responsibility of allocating objects from the collection of MarkedBlocks 10 that it manages. Also limited the amount of coupling to internal data fields 11 from other places, although it's mostly unavoidable in the JIT code. 12 13 Eventually MarkedAllocator will implement various policies to do with object 14 management, e.g. whether or not to run destructors on objects that it manages. 15 MarkedSpace will manage a collection of MarkedAllocators with varying policies, 16 as it does now but to a larger extent. 17 18 * CMakeLists.txt: 19 * GNUmakefile.list.am: 20 * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def: 21 * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj: 22 * JavaScriptCore.xcodeproj/project.pbxproj: 23 * Target.pri: 24 * dfg/DFGSpeculativeJIT.h: 25 (JSC::DFG::SpeculativeJIT::emitAllocateJSFinalObject): 26 * heap/Heap.cpp: 27 (JSC::Heap::collect): 28 (JSC::Heap::resetAllocators): 29 * heap/Heap.h: 30 (JSC::Heap::allocatorForObject): 31 (Heap): 32 * heap/MarkedAllocator.cpp: Added. 33 (JSC): 34 (JSC::MarkedAllocator::tryAllocateHelper): 35 (JSC::MarkedAllocator::tryAllocate): 36 (JSC::MarkedAllocator::allocateSlowCase): 37 (JSC::MarkedAllocator::allocateBlock): 38 (JSC::MarkedAllocator::addBlock): 39 (JSC::MarkedAllocator::removeBlock): 40 * heap/MarkedAllocator.h: Added. 41 (JSC): 42 (DFG): 43 (MarkedAllocator): 44 (JSC::MarkedAllocator::cellSize): 45 (JSC::MarkedAllocator::heap): 46 (JSC::MarkedAllocator::setHeap): 47 (JSC::MarkedAllocator::setCellSize): 48 (JSC::MarkedAllocator::setMarkedSpace): 49 (JSC::MarkedAllocator::MarkedAllocator): 50 (JSC::MarkedAllocator::allocate): 51 (JSC::MarkedAllocator::reset): 52 (JSC::MarkedAllocator::zapFreeList): 53 (JSC::MarkedAllocator::forEachBlock): 54 * heap/MarkedSpace.cpp: 55 (JSC::MarkedSpace::MarkedSpace): 56 (JSC::MarkedSpace::resetAllocators): 57 (JSC::MarkedSpace::canonicalizeCellLivenessData): 58 (JSC::TakeIfUnmarked::operator()): 59 * heap/MarkedSpace.h: 60 (MarkedSpace): 61 (JSC::MarkedSpace::allocatorFor): 62 (JSC::MarkedSpace::allocate): 63 (JSC::MarkedSpace::forEachBlock): 64 (JSC::MarkedSpace::didAddBlock): 65 (JSC::MarkedSpace::didConsumeFreeList): 66 * jit/JITInlineMethods.h: 67 (JSC::JIT::emitAllocateBasicJSObject): 68 1 69 2012-02-03 Simon Hausmann <simon.hausmann@nokia.com> 2 70 -
trunk/Source/JavaScriptCore/GNUmakefile.list.am
r106598 r106676 206 206 Source/JavaScriptCore/heap/MarkStack.h \ 207 207 Source/JavaScriptCore/heap/HeapRootVisitor.h \ 208 Source/JavaScriptCore/heap/MarkedAllocator.cpp \ 209 Source/JavaScriptCore/heap/MarkedAllocator.h \ 208 210 Source/JavaScriptCore/heap/MarkedBlock.cpp \ 209 211 Source/JavaScriptCore/heap/MarkedBlock.h \ -
trunk/Source/JavaScriptCore/JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def
r106454 r106676 65 65 ?addStaticGlobals@JSGlobalObject@JSC@@IAEXPAUGlobalPropertyInfo@12@H@Z 66 66 ?allocatePropertyStorage@JSObject@JSC@@QAEXAAVJSGlobalData@2@II@Z 67 ?allocateSlowCase@Marked Space@JSC@@AAEPAXAAUSizeClass@12@@Z67 ?allocateSlowCase@MarkedAllocator@JSC@@AAEPAXXZ 68 68 ?append@StringBuilder@WTF@@QAEXPBEI@Z 69 69 ?append@StringBuilder@WTF@@QAEXPB_WI@Z … … 284 284 ?releaseDecommitted@OSAllocator@WTF@@SAXPAXI@Z 285 285 ?releaseExecutableMemory@JSGlobalData@JSC@@QAEXXZ 286 ?removeBlock@MarkedAllocator@JSC@@QAEXPAVMarkedBlock@2@@Z 286 287 ?reportExtraMemoryCostSlowCase@Heap@JSC@@AAEXI@Z 287 288 ?reserveAndCommit@OSAllocator@WTF@@SAPAXIW4Usage@12@_N11@Z -
trunk/Source/JavaScriptCore/JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj
r106197 r106676 2067 2067 </File> 2068 2068 <File 2069 RelativePath="..\..\heap\MarkedAllocator.cpp" 2070 > 2071 </File> 2072 <File 2073 RelativePath="..\..\heap\MarkedAllocator.h" 2074 > 2075 </File> 2076 <File 2069 2077 RelativePath="..\..\heap\MarkedBlock.cpp" 2070 2078 > -
trunk/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj
r106606 r106676 722 722 C22C531513FAF6EF00B7DC0D /* utils.h in Headers */ = {isa = PBXBuildFile; fileRef = C22C52BB13FAF6EF00B7DC0D /* utils.h */; settings = {ATTRIBUTES = (Private, ); }; }; 723 723 C240305514B404E60079EB64 /* BumpSpace.cpp in Sources */ = {isa = PBXBuildFile; fileRef = C240305314B404C90079EB64 /* BumpSpace.cpp */; }; 724 C2B916C214DA014E00CBAC86 /* MarkedAllocator.h in Headers */ = {isa = PBXBuildFile; fileRef = C2B916C114DA014E00CBAC86 /* MarkedAllocator.h */; settings = {ATTRIBUTES = (Private, ); }; }; 725 C2B916C514DA040C00CBAC86 /* MarkedAllocator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = C2B916C414DA040C00CBAC86 /* MarkedAllocator.cpp */; }; 724 726 C2C8D02D14A3C6E000578E65 /* BumpSpaceInlineMethods.h in Headers */ = {isa = PBXBuildFile; fileRef = C2C8D02B14A3C6B200578E65 /* BumpSpaceInlineMethods.h */; settings = {ATTRIBUTES = (Private, ); }; }; 725 727 C2C8D03014A3CEFC00578E65 /* BumpBlock.h in Headers */ = {isa = PBXBuildFile; fileRef = C2C8D02E14A3CEFC00578E65 /* BumpBlock.h */; settings = {ATTRIBUTES = (Private, ); }; }; … … 1504 1506 C22C52BB13FAF6EF00B7DC0D /* utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = utils.h; sourceTree = "<group>"; }; 1505 1507 C240305314B404C90079EB64 /* BumpSpace.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = BumpSpace.cpp; sourceTree = "<group>"; }; 1508 C2B916C114DA014E00CBAC86 /* MarkedAllocator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MarkedAllocator.h; sourceTree = "<group>"; }; 1509 C2B916C414DA040C00CBAC86 /* MarkedAllocator.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MarkedAllocator.cpp; sourceTree = "<group>"; }; 1506 1510 C2C8D02B14A3C6B200578E65 /* BumpSpaceInlineMethods.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = BumpSpaceInlineMethods.h; sourceTree = "<group>"; }; 1507 1511 C2C8D02E14A3CEFC00578E65 /* BumpBlock.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = BumpBlock.h; sourceTree = "<group>"; }; … … 1801 1805 14B7233F12D7D0DA003BD5ED /* MachineStackMarker.cpp */, 1802 1806 14B7234012D7D0DA003BD5ED /* MachineStackMarker.h */, 1807 C2B916C414DA040C00CBAC86 /* MarkedAllocator.cpp */, 1808 C2B916C114DA014E00CBAC86 /* MarkedAllocator.h */, 1803 1809 142D6F0613539A2800B02E86 /* MarkedBlock.cpp */, 1804 1810 142D6F0713539A2800B02E86 /* MarkedBlock.h */, … … 2673 2679 C2D9CA1314BCC04600304B46 /* CheckedBoolean.h in Headers */, 2674 2680 A73BE16B148420520091204B /* ArrayBufferView.h in Headers */, 2681 C2B916C214DA014E00CBAC86 /* MarkedAllocator.h in Headers */, 2675 2682 BC18C3E60E16F5CD00B34460 /* ArrayConstructor.h in Headers */, 2676 2683 BC18C3E70E16F5CD00B34460 /* ArrayPrototype.h in Headers */, … … 3659 3666 86B5826714D2796C00A9C306 /* CodeProfile.cpp in Sources */, 3660 3667 86B5826914D2797000A9C306 /* CodeProfiling.cpp in Sources */, 3668 C2B916C514DA040C00CBAC86 /* MarkedAllocator.cpp in Sources */, 3661 3669 ); 3662 3670 runOnlyForDeploymentPostprocessing = 0; -
trunk/Source/JavaScriptCore/Target.pri
r106197 r106676 74 74 heap/MachineStackMarker.cpp \ 75 75 heap/MarkStack.cpp \ 76 heap/MarkedAllocator.cpp \ 76 77 heap/MarkedBlock.cpp \ 77 78 heap/MarkedSpace.cpp \ -
trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.h
r106502 r106676 34 34 #include "DFGOSRExit.h" 35 35 #include "DFGOperations.h" 36 #include "MarkedAllocator.h" 36 37 #include "ValueRecovery.h" 37 38 … … 1553 1554 void emitAllocateJSFinalObject(T structure, GPRReg resultGPR, GPRReg scratchGPR, MacroAssembler::JumpList& slowPath) 1554 1555 { 1555 Marked Space::SizeClass* sizeClass = &m_jit.globalData()->heap.sizeClassForObject(sizeof(JSFinalObject));1556 MarkedAllocator* allocator = &m_jit.globalData()->heap.allocatorForObject(sizeof(JSFinalObject)); 1556 1557 1557 m_jit.loadPtr(& sizeClass->firstFreeCell, resultGPR);1558 m_jit.loadPtr(&allocator->m_firstFreeCell, resultGPR); 1558 1559 slowPath.append(m_jit.branchTestPtr(MacroAssembler::Zero, resultGPR)); 1559 1560 … … 1567 1568 // Now that we have scratchGPR back, remove the object from the free list 1568 1569 m_jit.loadPtr(MacroAssembler::Address(resultGPR), scratchGPR); 1569 m_jit.storePtr(scratchGPR, & sizeClass->firstFreeCell);1570 m_jit.storePtr(scratchGPR, &allocator->m_firstFreeCell); 1570 1571 1571 1572 // Initialize the object's classInfo pointer -
trunk/Source/JavaScriptCore/heap/Heap.cpp
r105442 r106676 812 812 { 813 813 GCPHASE(ResetAllocator); 814 resetAllocator ();814 resetAllocators(); 815 815 } 816 816 … … 847 847 } 848 848 849 void Heap::resetAllocator ()849 void Heap::resetAllocators() 850 850 { 851 851 m_extraCost = 0; 852 m_objectSpace.resetAllocator ();852 m_objectSpace.resetAllocators(); 853 853 } 854 854 -
trunk/Source/JavaScriptCore/heap/Heap.h
r106078 r106676 26 26 #include "HandleHeap.h" 27 27 #include "HandleStack.h" 28 #include "MarkedAllocator.h" 28 29 #include "MarkedBlock.h" 29 30 #include "MarkedBlockSet.h" … … 95 96 inline bool isBusy(); 96 97 97 Marked Space::SizeClass& sizeClassForObject(size_t bytes) { return m_objectSpace.sizeClassFor(bytes); }98 MarkedAllocator& allocatorForObject(size_t bytes) { return m_objectSpace.allocatorFor(bytes); } 98 99 void* allocate(size_t); 99 100 CheckedBoolean tryAllocateStorage(size_t, void**); … … 137 138 private: 138 139 friend class MarkedSpace; 140 friend class MarkedAllocator; 139 141 friend class MarkedBlock; 140 142 friend class BumpSpace; … … 161 163 void canonicalizeCellLivenessData(); 162 164 163 void resetAllocator ();165 void resetAllocators(); 164 166 void freeBlocks(MarkedBlock*); 165 167 -
trunk/Source/JavaScriptCore/heap/MarkedSpace.cpp
r106078 r106676 36 36 , m_heap(heap) 37 37 { 38 for (size_t cellSize = preciseStep; cellSize <= preciseCutoff; cellSize += preciseStep) 39 sizeClassFor(cellSize).cellSize = cellSize; 38 for (size_t cellSize = preciseStep; cellSize <= preciseCutoff; cellSize += preciseStep) { 39 allocatorFor(cellSize).setCellSize(cellSize); 40 allocatorFor(cellSize).setHeap(heap); 41 allocatorFor(cellSize).setMarkedSpace(this); 42 } 40 43 41 for (size_t cellSize = impreciseStep; cellSize <= impreciseCutoff; cellSize += impreciseStep) 42 sizeClassFor(cellSize).cellSize = cellSize; 44 for (size_t cellSize = impreciseStep; cellSize <= impreciseCutoff; cellSize += impreciseStep) { 45 allocatorFor(cellSize).setCellSize(cellSize); 46 allocatorFor(cellSize).setHeap(heap); 47 allocatorFor(cellSize).setMarkedSpace(this); 48 } 43 49 } 44 50 45 void MarkedSpace::addBlock(SizeClass& sizeClass, MarkedBlock* block) 46 { 47 ASSERT(!sizeClass.currentBlock); 48 ASSERT(!sizeClass.firstFreeCell); 49 50 sizeClass.blockList.append(block); 51 sizeClass.currentBlock = block; 52 sizeClass.firstFreeCell = block->sweep(MarkedBlock::SweepToFreeList); 53 } 54 55 void MarkedSpace::removeBlock(MarkedBlock* block) 56 { 57 SizeClass& sizeClass = sizeClassFor(block->cellSize()); 58 if (sizeClass.currentBlock == block) 59 sizeClass.currentBlock = 0; 60 sizeClass.blockList.remove(block); 61 } 62 63 void MarkedSpace::resetAllocator() 51 void MarkedSpace::resetAllocators() 64 52 { 65 53 m_waterMark = 0; … … 67 55 68 56 for (size_t cellSize = preciseStep; cellSize <= preciseCutoff; cellSize += preciseStep) 69 sizeClassFor(cellSize).resetAllocator();57 allocatorFor(cellSize).reset(); 70 58 71 59 for (size_t cellSize = impreciseStep; cellSize <= impreciseCutoff; cellSize += impreciseStep) 72 sizeClassFor(cellSize).resetAllocator();60 allocatorFor(cellSize).reset(); 73 61 } 74 62 … … 76 64 { 77 65 for (size_t cellSize = preciseStep; cellSize <= preciseCutoff; cellSize += preciseStep) 78 sizeClassFor(cellSize).zapFreeList();66 allocatorFor(cellSize).zapFreeList(); 79 67 80 68 for (size_t cellSize = impreciseStep; cellSize <= impreciseCutoff; cellSize += impreciseStep) 81 sizeClassFor(cellSize).zapFreeList();69 allocatorFor(cellSize).zapFreeList(); 82 70 } 83 71 84 inline void* MarkedSpace::tryAllocateHelper(MarkedSpace::SizeClass& sizeClass)85 {86 MarkedBlock::FreeCell* firstFreeCell = sizeClass.firstFreeCell;87 if (!firstFreeCell) {88 for (MarkedBlock*& block = sizeClass.currentBlock; block; block = static_cast<MarkedBlock*>(block->next())) {89 firstFreeCell = block->sweep(MarkedBlock::SweepToFreeList);90 if (firstFreeCell)91 break;92 m_nurseryWaterMark += block->capacity() - block->size();93 m_waterMark += block->capacity();94 block->didConsumeFreeList();95 }96 97 if (!firstFreeCell)98 return 0;99 }100 101 ASSERT(firstFreeCell);102 sizeClass.firstFreeCell = firstFreeCell->next;103 return firstFreeCell;104 }105 106 inline void* MarkedSpace::tryAllocate(MarkedSpace::SizeClass& sizeClass)107 {108 m_heap->m_operationInProgress = Allocation;109 void* result = tryAllocateHelper(sizeClass);110 m_heap->m_operationInProgress = NoOperation;111 return result;112 }113 114 void* MarkedSpace::allocateSlowCase(MarkedSpace::SizeClass& sizeClass)115 {116 #if COLLECT_ON_EVERY_ALLOCATION117 m_heap->collectAllGarbage();118 ASSERT(m_heap->m_operationInProgress == NoOperation);119 #endif120 121 void* result = tryAllocate(sizeClass);122 123 if (LIKELY(result != 0))124 return result;125 126 AllocationEffort allocationEffort;127 128 if ((129 #if ENABLE(GGC)130 nurseryWaterMark() < m_heap->m_minBytesPerCycle131 #else132 m_heap->waterMark() < m_heap->highWaterMark()133 #endif134 ) || !m_heap->m_isSafeToCollect)135 allocationEffort = AllocationMustSucceed;136 else137 allocationEffort = AllocationCanFail;138 139 MarkedBlock* block = allocateBlock(sizeClass.cellSize, allocationEffort);140 if (block) {141 addBlock(sizeClass, block);142 void* result = tryAllocate(sizeClass);143 ASSERT(result);144 return result;145 }146 147 m_heap->collect(Heap::DoNotSweep);148 149 result = tryAllocate(sizeClass);150 151 if (result)152 return result;153 154 ASSERT(m_heap->waterMark() < m_heap->highWaterMark());155 156 addBlock(sizeClass, allocateBlock(sizeClass.cellSize, AllocationMustSucceed));157 158 result = tryAllocate(sizeClass);159 ASSERT(result);160 return result;161 }162 163 MarkedBlock* MarkedSpace::allocateBlock(size_t cellSize, AllocationEffort allocationEffort)164 {165 MarkedBlock* block;166 167 {168 MutexLocker locker(m_heap->m_freeBlockLock);169 if (m_heap->m_numberOfFreeBlocks) {170 block = static_cast<MarkedBlock*>(m_heap->m_freeBlocks.removeHead());171 ASSERT(block);172 m_heap->m_numberOfFreeBlocks--;173 } else174 block = 0;175 }176 if (block)177 block = MarkedBlock::recycle(block, m_heap, cellSize);178 else if (allocationEffort == AllocationCanFail)179 return 0;180 else181 block = MarkedBlock::create(m_heap, cellSize);182 183 m_blocks.add(block);184 185 return block;186 }187 72 188 73 void MarkedSpace::freeBlocks(MarkedBlock* head) … … 223 108 return; 224 109 225 m_markedSpace-> removeBlock(block);110 m_markedSpace->allocatorFor(block->cellSize()).removeBlock(block); 226 111 m_empties.append(block); 227 112 } -
trunk/Source/JavaScriptCore/heap/MarkedSpace.h
r106433 r106676 24 24 25 25 #include "MachineStackMarker.h" 26 #include "MarkedAllocator.h" 26 27 #include "MarkedBlock.h" 27 28 #include "MarkedBlockSet.h" … … 49 50 static const size_t maxCellSize = 2048; 50 51 51 struct SizeClass {52 SizeClass();53 void resetAllocator();54 void zapFreeList();55 56 MarkedBlock::FreeCell* firstFreeCell;57 MarkedBlock* currentBlock;58 DoublyLinkedList<HeapBlock> blockList;59 size_t cellSize;60 };61 62 52 MarkedSpace(Heap*); 63 53 64 SizeClass& sizeClassFor(size_t);54 MarkedAllocator& allocatorFor(size_t); 65 55 void* allocate(size_t); 66 void* allocate(SizeClass&);67 56 68 void resetAllocator ();57 void resetAllocators(); 69 58 70 void addBlock(SizeClass&, MarkedBlock*);71 void removeBlock(MarkedBlock*);72 59 MarkedBlockSet& blocks() { return m_blocks; } 73 60 … … 86 73 void shrink(); 87 74 void freeBlocks(MarkedBlock* head); 75 void didAddBlock(MarkedBlock*); 76 void didConsumeFreeList(MarkedBlock*); 88 77 89 78 private: 90 JS_EXPORT_PRIVATE void* allocateSlowCase(SizeClass&);91 void* tryAllocateHelper(MarkedSpace::SizeClass&);92 void* tryAllocate(MarkedSpace::SizeClass&);93 MarkedBlock* allocateBlock(size_t, AllocationEffort);94 95 79 // [ 32... 256 ] 96 80 static const size_t preciseStep = MarkedBlock::atomSize; … … 103 87 static const size_t impreciseCount = impreciseCutoff / impreciseStep; 104 88 105 FixedArray< SizeClass, preciseCount> m_preciseSizeClasses;106 FixedArray< SizeClass, impreciseCount> m_impreciseSizeClasses;89 FixedArray<MarkedAllocator, preciseCount> m_preciseSizeClasses; 90 FixedArray<MarkedAllocator, impreciseCount> m_impreciseSizeClasses; 107 91 size_t m_waterMark; 108 92 size_t m_nurseryWaterMark; … … 137 121 } 138 122 139 inline Marked Space::SizeClass& MarkedSpace::sizeClassFor(size_t bytes)123 inline MarkedAllocator& MarkedSpace::allocatorFor(size_t bytes) 140 124 { 141 125 ASSERT(bytes && bytes <= maxCellSize); … … 147 131 inline void* MarkedSpace::allocate(size_t bytes) 148 132 { 149 SizeClass& sizeClass = sizeClassFor(bytes); 150 return allocate(sizeClass); 151 } 152 153 inline void* MarkedSpace::allocate(SizeClass& sizeClass) 154 { 155 // This is a light-weight fast path to cover the most common case. 156 MarkedBlock::FreeCell* firstFreeCell = sizeClass.firstFreeCell; 157 if (UNLIKELY(!firstFreeCell)) 158 return allocateSlowCase(sizeClass); 159 160 sizeClass.firstFreeCell = firstFreeCell->next; 161 return firstFreeCell; 133 return allocatorFor(bytes).allocate(); 162 134 } 163 135 … … 165 137 { 166 138 for (size_t i = 0; i < preciseCount; ++i) { 167 SizeClass& sizeClass = m_preciseSizeClasses[i]; 168 HeapBlock* next; 169 for (HeapBlock* block = sizeClass.blockList.head(); block; block = next) { 170 next = block->next(); 171 functor(static_cast<MarkedBlock*>(block)); 172 } 139 m_preciseSizeClasses[i].forEachBlock(functor); 173 140 } 174 141 175 142 for (size_t i = 0; i < impreciseCount; ++i) { 176 SizeClass& sizeClass = m_impreciseSizeClasses[i]; 177 HeapBlock* next; 178 for (HeapBlock* block = sizeClass.blockList.head(); block; block = next) { 179 next = block->next(); 180 functor(static_cast<MarkedBlock*>(block)); 181 } 143 m_impreciseSizeClasses[i].forEachBlock(functor); 182 144 } 183 145 … … 191 153 } 192 154 193 inline MarkedSpace::SizeClass::SizeClass() 194 : firstFreeCell(0) 195 , currentBlock(0) 196 , cellSize(0) 155 inline void MarkedSpace::didAddBlock(MarkedBlock* block) 197 156 { 157 m_blocks.add(block); 198 158 } 199 159 200 inline void MarkedSpace:: SizeClass::resetAllocator()160 inline void MarkedSpace::didConsumeFreeList(MarkedBlock* block) 201 161 { 202 currentBlock = static_cast<MarkedBlock*>(blockList.head()); 203 } 204 205 inline void MarkedSpace::SizeClass::zapFreeList() 206 { 207 if (!currentBlock) { 208 ASSERT(!firstFreeCell); 209 return; 210 } 211 212 currentBlock->zapFreeList(firstFreeCell); 213 firstFreeCell = 0; 162 m_nurseryWaterMark += block->capacity() - block->size(); 163 m_waterMark += block->capacity(); 214 164 } 215 165 -
trunk/Source/JavaScriptCore/jit/JITInlineMethods.h
r105533 r106676 402 402 template <typename ClassType, typename StructureType> inline void JIT::emitAllocateBasicJSObject(StructureType structure, RegisterID result, RegisterID storagePtr) 403 403 { 404 Marked Space::SizeClass* sizeClass = &m_globalData->heap.sizeClassForObject(sizeof(ClassType));405 loadPtr(& sizeClass->firstFreeCell, result);404 MarkedAllocator* allocator = &m_globalData->heap.allocatorForObject(sizeof(ClassType)); 405 loadPtr(&allocator->m_firstFreeCell, result); 406 406 addSlowCase(branchTestPtr(Zero, result)); 407 407 408 408 // remove the object from the free list 409 409 loadPtr(Address(result), storagePtr); 410 storePtr(storagePtr, & sizeClass->firstFreeCell);410 storePtr(storagePtr, &allocator->m_firstFreeCell); 411 411 412 412 // initialize the object's structure
Note: See TracChangeset
for help on using the changeset viewer.