Changeset 95450 in webkit
- Timestamp:
- Sep 19, 2011 11:54:33 AM (13 years ago)
- Location:
- trunk/Source/JavaScriptCore
- Files:
-
- 8 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/Source/JavaScriptCore/ChangeLog
r95449 r95450 1 2011-09-19 Oliver Hunt <oliver@apple.com> 2 3 Rename NewSpace to MarkedSpace 4 https://bugs.webkit.org/show_bug.cgi?id=68375 5 6 Reviewed by Gavin Barraclough. 7 8 Rename NewSpace to a more accurate name, and update all uses. 9 This patch doesn't rename the files themselves as that will 10 just make the patch appear bigger than it is. 11 12 * JavaScriptCore.exp: 13 * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def: 14 * heap/Heap.cpp: 15 (JSC::CountFunctor::TakeIfEmpty::TakeIfEmpty): 16 (JSC::CountFunctor::TakeIfEmpty::operator()): 17 (JSC::Heap::Heap): 18 (JSC::Heap::reportExtraMemoryCostSlowCase): 19 (JSC::Heap::tryAllocate): 20 (JSC::Heap::allocateSlowCase): 21 (JSC::Heap::collect): 22 (JSC::Heap::canonicalizeBlocks): 23 (JSC::Heap::resetAllocator): 24 (JSC::Heap::isValidAllocation): 25 (JSC::Heap::shrink): 26 * heap/Heap.h: 27 (JSC::Heap::markedSpace): 28 (JSC::Heap::sizeClassFor): 29 (JSC::Heap::allocate): 30 * heap/NewSpace.cpp: 31 (JSC::MarkedSpace::MarkedSpace): 32 (JSC::MarkedSpace::addBlock): 33 (JSC::MarkedSpace::removeBlock): 34 (JSC::MarkedSpace::resetAllocator): 35 (JSC::MarkedSpace::canonicalizeBlocks): 36 * heap/NewSpace.h: 37 (JSC::MarkedSpace::waterMark): 38 (JSC::MarkedSpace::highWaterMark): 39 (JSC::MarkedSpace::setHighWaterMark): 40 (JSC::MarkedSpace::sizeClassFor): 41 (JSC::MarkedSpace::allocate): 42 (JSC::MarkedSpace::forEachBlock): 43 (JSC::MarkedSpace::SizeClass::SizeClass): 44 (JSC::MarkedSpace::SizeClass::resetAllocator): 45 (JSC::MarkedSpace::SizeClass::canonicalizeBlock): 46 * jit/JITInlineMethods.h: 47 (JSC::JIT::emitAllocateBasicJSObject): 48 1 49 2011-09-19 Peter Rybin <peter.rybin@gmail.com> 2 50 -
trunk/Source/JavaScriptCore/JavaScriptCore.exp
r95318 r95450 234 234 __ZN3JSC4Heap11objectCountEv 235 235 __ZN3JSC4Heap16activityCallbackEv 236 __ZN3JSC4Heap16allocateSlowCaseERNS_ 8NewSpace9SizeClassE236 __ZN3JSC4Heap16allocateSlowCaseERNS_11MarkedSpace9SizeClassE 237 237 __ZN3JSC4Heap16objectTypeCountsEv 238 238 __ZN3JSC4Heap17collectAllGarbageEv -
trunk/Source/JavaScriptCore/JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def
r95321 r95450 60 60 ?addSlowCase@Identifier@JSC@@CA?AV?$PassRefPtr@VStringImpl@WTF@@@WTF@@PAVExecState@2@PAVStringImpl@4@@Z 61 61 ?addStaticGlobals@JSGlobalObject@JSC@@IAEXPAUGlobalPropertyInfo@12@H@Z 62 ?allocate@Heap@JSC@@QAEPAXAAUSizeClass@ NewSpace@2@@Z62 ?allocate@Heap@JSC@@QAEPAXAAUSizeClass@MarkedSpace@2@@Z 63 63 ?allocatePropertyStorage@JSObject@JSC@@QAEXAAVJSGlobalData@2@II@Z 64 ?allocateSlowCase@Heap@JSC@@AAEPAXAAUSizeClass@ NewSpace@2@@Z64 ?allocateSlowCase@Heap@JSC@@AAEPAXAAUSizeClass@MarkedSpace@2@@Z 65 65 ?append@StringBuilder@WTF@@QAEXPBDI@Z 66 66 ?append@StringBuilder@WTF@@QAEXPB_WI@Z -
trunk/Source/JavaScriptCore/heap/Heap.cpp
r95439 r95450 180 180 typedef MarkedBlock* ReturnType; 181 181 182 TakeIfEmpty( NewSpace*);182 TakeIfEmpty(MarkedSpace*); 183 183 void operator()(MarkedBlock*); 184 184 ReturnType returnValue(); 185 185 186 186 private: 187 NewSpace* m_newSpace;187 MarkedSpace* m_markedSpace; 188 188 DoublyLinkedList<MarkedBlock> m_empties; 189 189 }; 190 190 191 inline TakeIfEmpty::TakeIfEmpty( NewSpace* newSpace)192 : m_ newSpace(newSpace)191 inline TakeIfEmpty::TakeIfEmpty(MarkedSpace* newSpace) 192 : m_markedSpace(newSpace) 193 193 { 194 194 } … … 199 199 return; 200 200 201 m_ newSpace->removeBlock(block);201 m_markedSpace->removeBlock(block); 202 202 m_empties.append(block); 203 203 } … … 250 250 , m_minBytesPerCycle(heapSizeForHint(heapSize)) 251 251 , m_operationInProgress(NoOperation) 252 , m_ newSpace(this)252 , m_markedSpace(this) 253 253 , m_extraCost(0) 254 254 , m_markListSet(0) … … 260 260 , m_globalData(globalData) 261 261 { 262 m_ newSpace.setHighWaterMark(m_minBytesPerCycle);262 m_markedSpace.setHighWaterMark(m_minBytesPerCycle); 263 263 (*m_activityCallback)(); 264 264 #if ENABLE(LAZY_BLOCK_FREEING) … … 402 402 // collecting more frequently as long as it stays alive. 403 403 404 if (m_extraCost > maxExtraCost && m_extraCost > m_ newSpace.highWaterMark() / 2)404 if (m_extraCost > maxExtraCost && m_extraCost > m_markedSpace.highWaterMark() / 2) 405 405 collectAllGarbage(); 406 406 m_extraCost += cost; 407 407 } 408 408 409 inline void* Heap::tryAllocate( NewSpace::SizeClass& sizeClass)409 inline void* Heap::tryAllocate(MarkedSpace::SizeClass& sizeClass) 410 410 { 411 411 m_operationInProgress = Allocation; 412 void* result = m_ newSpace.allocate(sizeClass);412 void* result = m_markedSpace.allocate(sizeClass); 413 413 m_operationInProgress = NoOperation; 414 414 return result; 415 415 } 416 416 417 void* Heap::allocateSlowCase( NewSpace::SizeClass& sizeClass)417 void* Heap::allocateSlowCase(MarkedSpace::SizeClass& sizeClass) 418 418 { 419 419 #if COLLECT_ON_EVERY_ALLOCATION … … 429 429 AllocationEffort allocationEffort; 430 430 431 if (m_ newSpace.waterMark() < m_newSpace.highWaterMark() || !m_isSafeToCollect)431 if (m_markedSpace.waterMark() < m_markedSpace.highWaterMark() || !m_isSafeToCollect) 432 432 allocationEffort = AllocationMustSucceed; 433 433 else … … 436 436 MarkedBlock* block = allocateBlock(sizeClass.cellSize, allocationEffort); 437 437 if (block) { 438 m_ newSpace.addBlock(sizeClass, block);438 m_markedSpace.addBlock(sizeClass, block); 439 439 void* result = tryAllocate(sizeClass); 440 440 ASSERT(result); … … 449 449 return result; 450 450 451 ASSERT(m_ newSpace.waterMark() < m_newSpace.highWaterMark());452 453 m_ newSpace.addBlock(sizeClass, allocateBlock(sizeClass.cellSize, AllocationMustSucceed));451 ASSERT(m_markedSpace.waterMark() < m_markedSpace.highWaterMark()); 452 453 m_markedSpace.addBlock(sizeClass, allocateBlock(sizeClass.cellSize, AllocationMustSucceed)); 454 454 455 455 result = tryAllocate(sizeClass); … … 692 692 // new bytes allocated) proportion, and seems to work well in benchmarks. 693 693 size_t proportionalBytes = 2 * size(); 694 m_ newSpace.setHighWaterMark(max(proportionalBytes, m_minBytesPerCycle));694 m_markedSpace.setHighWaterMark(max(proportionalBytes, m_minBytesPerCycle)); 695 695 JAVASCRIPTCORE_GC_END(); 696 696 … … 700 700 void Heap::canonicalizeBlocks() 701 701 { 702 m_ newSpace.canonicalizeBlocks();702 m_markedSpace.canonicalizeBlocks(); 703 703 } 704 704 … … 706 706 { 707 707 m_extraCost = 0; 708 m_ newSpace.resetAllocator();708 m_markedSpace.resetAllocator(); 709 709 } 710 710 … … 724 724 return false; 725 725 726 if (bytes > NewSpace::maxCellSize)726 if (bytes > MarkedSpace::maxCellSize) 727 727 return false; 728 728 … … 786 786 { 787 787 // We record a temporary list of empties to avoid modifying m_blocks while iterating it. 788 TakeIfEmpty takeIfEmpty(&m_ newSpace);788 TakeIfEmpty takeIfEmpty(&m_markedSpace); 789 789 freeBlocks(forEachBlock(takeIfEmpty)); 790 790 } -
trunk/Source/JavaScriptCore/heap/Heap.h
r95439 r95450 77 77 78 78 JSGlobalData* globalData() const { return m_globalData; } 79 NewSpace& markedSpace() { return m_newSpace; }79 MarkedSpace& markedSpace() { return m_markedSpace; } 80 80 MachineThreads& machineThreads() { return m_machineThreads; } 81 81 … … 87 87 88 88 void* allocate(size_t); 89 NewSpace::SizeClass& sizeClassFor(size_t);90 void* allocate( NewSpace::SizeClass&);89 MarkedSpace::SizeClass& sizeClassFor(size_t); 90 void* allocate(MarkedSpace::SizeClass&); 91 91 void notifyIsSafeToCollect() { m_isSafeToCollect = true; } 92 92 void collectAllGarbage(); … … 152 152 void harvestWeakReferences(); 153 153 154 void* tryAllocate( NewSpace::SizeClass&);155 void* allocateSlowCase( NewSpace::SizeClass&);154 void* tryAllocate(MarkedSpace::SizeClass&); 155 void* allocateSlowCase(MarkedSpace::SizeClass&); 156 156 157 157 enum SweepToggle { DoNotSweep, DoSweep }; … … 176 176 177 177 OperationInProgress m_operationInProgress; 178 NewSpace m_newSpace;178 MarkedSpace m_markedSpace; 179 179 MarkedBlockSet m_blocks; 180 180 … … 337 337 } 338 338 339 inline NewSpace::SizeClass& Heap::sizeClassFor(size_t bytes)340 { 341 return m_ newSpace.sizeClassFor(bytes);342 } 343 344 inline void* Heap::allocate( NewSpace::SizeClass& sizeClass)339 inline MarkedSpace::SizeClass& Heap::sizeClassFor(size_t bytes) 340 { 341 return m_markedSpace.sizeClassFor(bytes); 342 } 343 344 inline void* Heap::allocate(MarkedSpace::SizeClass& sizeClass) 345 345 { 346 346 // This is a light-weight fast path to cover the most common case. … … 356 356 { 357 357 ASSERT(isValidAllocation(bytes)); 358 NewSpace::SizeClass& sizeClass = sizeClassFor(bytes);358 MarkedSpace::SizeClass& sizeClass = sizeClassFor(bytes); 359 359 return allocate(sizeClass); 360 360 } -
trunk/Source/JavaScriptCore/heap/NewSpace.cpp
r95439 r95450 32 32 class Structure; 33 33 34 NewSpace::NewSpace(Heap* heap)34 MarkedSpace::MarkedSpace(Heap* heap) 35 35 : m_waterMark(0) 36 36 , m_highWaterMark(0) … … 44 44 } 45 45 46 void NewSpace::addBlock(SizeClass& sizeClass, MarkedBlock* block)46 void MarkedSpace::addBlock(SizeClass& sizeClass, MarkedBlock* block) 47 47 { 48 48 block->setInNewSpace(true); … … 55 55 } 56 56 57 void NewSpace::removeBlock(MarkedBlock* block)57 void MarkedSpace::removeBlock(MarkedBlock* block) 58 58 { 59 59 block->setInNewSpace(false); … … 64 64 } 65 65 66 void NewSpace::resetAllocator()66 void MarkedSpace::resetAllocator() 67 67 { 68 68 m_waterMark = 0; … … 75 75 } 76 76 77 void NewSpace::canonicalizeBlocks()77 void MarkedSpace::canonicalizeBlocks() 78 78 { 79 79 for (size_t cellSize = preciseStep; cellSize < preciseCutoff; cellSize += preciseStep) -
trunk/Source/JavaScriptCore/heap/NewSpace.h
r95439 r95450 33 33 #include <wtf/Vector.h> 34 34 35 #define ASSERT_CLASS_FITS_IN_CELL(class) COMPILE_ASSERT(sizeof(class) < NewSpace::maxCellSize, class_fits_in_cell)35 #define ASSERT_CLASS_FITS_IN_CELL(class) COMPILE_ASSERT(sizeof(class) < MarkedSpace::maxCellSize, class_fits_in_cell) 36 36 37 37 namespace JSC { … … 43 43 class SlotVisitor; 44 44 45 class NewSpace {46 WTF_MAKE_NONCOPYABLE( NewSpace);45 class MarkedSpace { 46 WTF_MAKE_NONCOPYABLE(MarkedSpace); 47 47 public: 48 48 static const size_t maxCellSize = 1024; … … 60 60 }; 61 61 62 NewSpace(Heap*);62 MarkedSpace(Heap*); 63 63 64 64 SizeClass& sizeClassFor(size_t); … … 98 98 }; 99 99 100 inline size_t NewSpace::waterMark()100 inline size_t MarkedSpace::waterMark() 101 101 { 102 102 return m_waterMark; 103 103 } 104 104 105 inline size_t NewSpace::highWaterMark()105 inline size_t MarkedSpace::highWaterMark() 106 106 { 107 107 return m_highWaterMark; 108 108 } 109 109 110 inline void NewSpace::setHighWaterMark(size_t highWaterMark)110 inline void MarkedSpace::setHighWaterMark(size_t highWaterMark) 111 111 { 112 112 m_highWaterMark = highWaterMark; 113 113 } 114 114 115 inline NewSpace::SizeClass& NewSpace::sizeClassFor(size_t bytes)115 inline MarkedSpace::SizeClass& MarkedSpace::sizeClassFor(size_t bytes) 116 116 { 117 117 ASSERT(bytes && bytes < maxCellSize); … … 121 121 } 122 122 123 inline void* NewSpace::allocate(SizeClass& sizeClass)123 inline void* MarkedSpace::allocate(SizeClass& sizeClass) 124 124 { 125 125 MarkedBlock::FreeCell* firstFreeCell = sizeClass.firstFreeCell; … … 162 162 } 163 163 164 template <typename Functor> inline typename Functor::ReturnType NewSpace::forEachBlock(Functor& functor)164 template <typename Functor> inline typename Functor::ReturnType MarkedSpace::forEachBlock(Functor& functor) 165 165 { 166 166 for (size_t i = 0; i < preciseCount; ++i) { … … 185 185 } 186 186 187 template <typename Functor> inline typename Functor::ReturnType NewSpace::forEachBlock()187 template <typename Functor> inline typename Functor::ReturnType MarkedSpace::forEachBlock() 188 188 { 189 189 Functor functor; … … 191 191 } 192 192 193 inline NewSpace::SizeClass::SizeClass()193 inline MarkedSpace::SizeClass::SizeClass() 194 194 : firstFreeCell(0) 195 195 , currentBlock(0) … … 199 199 } 200 200 201 inline void NewSpace::SizeClass::resetAllocator()201 inline void MarkedSpace::SizeClass::resetAllocator() 202 202 { 203 203 nextBlock = blockList.head(); 204 204 } 205 205 206 inline void NewSpace::SizeClass::canonicalizeBlock()206 inline void MarkedSpace::SizeClass::canonicalizeBlock() 207 207 { 208 208 if (currentBlock) { -
trunk/Source/JavaScriptCore/jit/JITInlineMethods.h
r95326 r95450 387 387 template <typename ClassType, typename StructureType> inline void JIT::emitAllocateBasicJSObject(StructureType structure, void* vtable, RegisterID result, RegisterID storagePtr) 388 388 { 389 NewSpace::SizeClass* sizeClass = &m_globalData->heap.sizeClassFor(sizeof(ClassType));389 MarkedSpace::SizeClass* sizeClass = &m_globalData->heap.sizeClassFor(sizeof(ClassType)); 390 390 loadPtr(&sizeClass->firstFreeCell, result); 391 391 addSlowCase(branchTestPtr(Zero, result));
Note: See TracChangeset
for help on using the changeset viewer.