Changeset 87653 in webkit
- Timestamp:
- May 29, 2011 2:56:53 PM (13 years ago)
- Location:
- trunk/Source/JavaScriptCore
- Files:
-
- 9 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/Source/JavaScriptCore/ChangeLog
r87614 r87653 1 2011-05-29 Geoffrey Garen <ggaren@apple.com> 2 3 Reviewed by Sam Weinig. 4 5 Some heap refactoring 6 https://bugs.webkit.org/show_bug.cgi?id=61704 7 8 SunSpider says no change. 9 10 * JavaScriptCore.exp: Export! 11 12 * heap/Heap.cpp: COLLECT_ON_EVERY_ALLOCATION can actually do so now. 13 14 (JSC::Heap::Heap): Changed Heap sub-objects to point to the heap. 15 16 (JSC::Heap::allocate): Changed inline allocation code to only select the 17 size class, since this can be optimized out at compile time -- everything 18 else is now inlined into this out-of-line function. 19 20 No need to duplicate ASSERTs made in our caller. 21 22 * heap/Heap.h: 23 (JSC::Heap::heap): 24 (JSC::Heap::isMarked): 25 (JSC::Heap::testAndSetMarked): 26 (JSC::Heap::testAndClearMarked): 27 (JSC::Heap::setMarked): Call directly into MarkedBlock instead of adding 28 a layer of indirection through MarkedSpace. 29 30 (JSC::Heap::allocate): See above. 31 32 * heap/MarkedBlock.cpp: 33 (JSC::MarkedBlock::create): 34 (JSC::MarkedBlock::MarkedBlock): 35 * heap/MarkedBlock.h: Changed Heap sub-objects to point to the heap. 36 37 * heap/MarkedSpace.cpp: 38 (JSC::MarkedSpace::MarkedSpace): 39 (JSC::MarkedSpace::allocateBlock): 40 * heap/MarkedSpace.h: 41 (JSC::MarkedSpace::allocate): Updated to match changes above. 42 1 43 2011-05-28 David Kilzer <ddkilzer@apple.com> 2 44 -
trunk/Source/JavaScriptCore/JavaScriptCore.exp
r87434 r87653 117 117 __ZN3JSC11JSByteArray15createStructureERNS_12JSGlobalDataENS_7JSValueEPKNS_9ClassInfoE 118 118 __ZN3JSC11JSByteArrayC1EPNS_9ExecStateEPNS_9StructureEPN3WTF9ByteArrayE 119 __ZN3JSC11MarkedSpace21allocateFromSizeClassERNS0_9SizeClassE120 119 __ZN3JSC11ParserArena5resetEv 121 120 __ZN3JSC11checkSyntaxEPNS_9ExecStateERKNS_10SourceCodeE … … 224 223 __ZN3JSC41constructFunctionSkippingEvalEnabledCheckEPNS_9ExecStateEPNS_14JSGlobalObjectERKNS_7ArgListERKNS_10IdentifierERKNS_7UStringEi 225 224 __ZN3JSC4Heap16activityCallbackEv 226 __ZN3JSC4Heap16allocateSlowCaseEm227 225 __ZN3JSC4Heap16objectTypeCountsEv 228 226 __ZN3JSC4Heap17collectAllGarbageEv … … 236 234 __ZN3JSC4Heap7destroyEv 237 235 __ZN3JSC4Heap7protectENS_7JSValueE 236 __ZN3JSC4Heap8allocateERNS_11MarkedSpace9SizeClassE 238 237 __ZN3JSC4Heap9unprotectENS_7JSValueE 239 238 __ZN3JSC4Yarr11YarrPatternC1ERKNS_7UStringEbbPPKc -
trunk/Source/JavaScriptCore/JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def
r87440 r87653 57 57 ?addSlowCase@Identifier@JSC@@CA?AV?$PassRefPtr@VStringImpl@WTF@@@WTF@@PAVExecState@2@PAVStringImpl@4@@Z 58 58 ?addStaticGlobals@JSGlobalObject@JSC@@IAEXPAUGlobalPropertyInfo@12@H@Z 59 ?allocate@Heap@JSC@@QAEPAXAAUSizeClass@MarkedSpace@2@@Z 59 60 ?allocate@Heap@JSC@@QAEPAXI@Z 60 ?allocateFromSizeClass@MarkedSpace@JSC@@AAEPAXAAUSizeClass@12@@Z61 61 ?allocatePropertyStorage@JSObject@JSC@@QAEXII@Z 62 ?allocateSlowCase@Heap@JSC@@AAEPAXI@Z63 62 ?append@StringBuilder@WTF@@QAEXPBDI@Z 64 63 ?append@StringBuilder@WTF@@QAEXPB_WI@Z -
trunk/Source/JavaScriptCore/heap/Heap.cpp
r87450 r87653 34 34 #include <algorithm> 35 35 36 #define COLLECT_ON_EVERY_ SLOW_ALLOCATION 036 #define COLLECT_ON_EVERY_ALLOCATION 0 37 37 38 38 using namespace std; … … 66 66 Heap::Heap(JSGlobalData* globalData) 67 67 : m_operationInProgress(NoOperation) 68 , m_markedSpace( globalData)68 , m_markedSpace(this) 69 69 , m_markListSet(0) 70 70 , m_activityCallback(DefaultGCActivityCallback::create(this)) … … 131 131 } 132 132 133 void* Heap::allocateSlowCase(size_t bytes) 134 { 135 ASSERT(globalData()->identifierTable == wtfThreadData().currentIdentifierTable()); 136 ASSERT(JSLock::lockCount() > 0); 137 ASSERT(JSLock::currentThreadIsHoldingLock()); 138 ASSERT(bytes <= MarkedSpace::maxCellSize); 139 ASSERT(m_operationInProgress == NoOperation); 140 141 #if COLLECT_ON_EVERY_SLOW_ALLOCATION 133 void* Heap::allocate(MarkedSpace::SizeClass& sizeClass) 134 { 135 #if COLLECT_ON_EVERY_ALLOCATION 142 136 collectAllGarbage(); 143 137 ASSERT(m_operationInProgress == NoOperation); 144 138 #endif 145 139 140 void* result = m_markedSpace.allocate(sizeClass); 141 if (result) 142 return result; 143 146 144 reset(DoNotSweep); 147 145 148 146 m_operationInProgress = Allocation; 149 void* result = m_markedSpace.allocate(bytes);147 result = m_markedSpace.allocate(sizeClass); 150 148 m_operationInProgress = NoOperation; 151 149 -
trunk/Source/JavaScriptCore/heap/Heap.h
r87522 r87653 82 82 83 83 void* allocate(size_t); 84 void* allocate(MarkedSpace::SizeClass&); 84 85 void collectAllGarbage(); 85 86 … … 113 114 114 115 private: 115 friend class JSGlobalData;116 117 116 static const size_t minExtraCost = 256; 118 117 static const size_t maxExtraCost = 1024 * 1024; … … 156 155 } 157 156 158 inline bool Heap::isMarked(const void* cell) 159 { 160 return MarkedSpace::isMarked(cell); 161 } 162 163 inline bool Heap::testAndSetMarked(const void* cell) 164 { 165 return MarkedSpace::testAndSetMarked(cell); 166 } 167 168 inline bool Heap::testAndClearMarked(const void* cell) 169 { 170 return MarkedSpace::testAndClearMarked(cell); 171 } 172 173 inline void Heap::setMarked(const void* cell) 174 { 175 MarkedSpace::setMarked(cell); 176 } 177 178 inline void Heap::writeBarrier(const JSCell*, JSValue) 179 { 180 } 181 182 inline void Heap::writeBarrier(const JSCell*, JSCell*) 183 { 184 } 185 186 inline bool Heap::contains(void* p) 187 { 188 return m_markedSpace.contains(p); 189 } 190 191 inline void Heap::reportExtraMemoryCost(size_t cost) 192 { 193 if (cost > minExtraCost) 194 reportExtraMemoryCostSlowCase(cost); 195 } 196 197 template <typename Functor> inline void Heap::forEach(Functor& functor) 198 { 199 m_markedSpace.forEach(functor); 200 } 201 202 inline void* Heap::allocate(size_t bytes) 203 { 204 ASSERT(isValidAllocation(bytes)); 205 206 m_operationInProgress = Allocation; 207 void* result = m_markedSpace.allocate(bytes); 208 m_operationInProgress = NoOperation; 209 if (result) 210 return result; 211 212 return allocateSlowCase(bytes); 157 inline Heap* Heap::heap(JSCell* cell) 158 { 159 return MarkedBlock::blockFor(cell)->heap(); 213 160 } 214 161 … … 220 167 } 221 168 222 inline Heap* Heap::heap(JSCell* c) 223 { 224 return MarkedSpace::heap(c); 169 inline bool Heap::isMarked(const void* cell) 170 { 171 return MarkedBlock::blockFor(cell)->isMarked(cell); 172 } 173 174 inline bool Heap::testAndSetMarked(const void* cell) 175 { 176 return MarkedBlock::blockFor(cell)->testAndSetMarked(cell); 177 } 178 179 inline bool Heap::testAndClearMarked(const void* cell) 180 { 181 return MarkedBlock::blockFor(cell)->testAndClearMarked(cell); 182 } 183 184 inline void Heap::setMarked(const void* cell) 185 { 186 MarkedBlock::blockFor(cell)->setMarked(cell); 187 } 188 189 inline void Heap::writeBarrier(const JSCell*, JSValue) 190 { 191 } 192 193 inline void Heap::writeBarrier(const JSCell*, JSCell*) 194 { 195 } 196 197 inline bool Heap::contains(void* p) 198 { 199 return m_markedSpace.contains(p); 200 } 201 202 inline void Heap::reportExtraMemoryCost(size_t cost) 203 { 204 if (cost > minExtraCost) 205 reportExtraMemoryCostSlowCase(cost); 206 } 207 208 template <typename Functor> inline void Heap::forEach(Functor& functor) 209 { 210 m_markedSpace.forEach(functor); 211 } 212 213 inline void* Heap::allocate(size_t bytes) 214 { 215 ASSERT(isValidAllocation(bytes)); 216 MarkedSpace::SizeClass& sizeClass = m_markedSpace.sizeClassFor(bytes); 217 return allocate(sizeClass); 225 218 } 226 219 -
trunk/Source/JavaScriptCore/heap/MarkedBlock.cpp
r87427 r87653 34 34 namespace JSC { 35 35 36 MarkedBlock* MarkedBlock::create( JSGlobalData* globalData, size_t cellSize)36 MarkedBlock* MarkedBlock::create(Heap* heap, size_t cellSize) 37 37 { 38 38 PageAllocationAligned allocation = PageAllocationAligned::allocate(blockSize, blockSize, OSAllocator::JSGCHeapPages); 39 39 if (!static_cast<bool>(allocation)) 40 40 CRASH(); 41 return new (allocation.base()) MarkedBlock(allocation, globalData, cellSize);41 return new (allocation.base()) MarkedBlock(allocation, heap, cellSize); 42 42 } 43 43 … … 49 49 } 50 50 51 MarkedBlock::MarkedBlock(const PageAllocationAligned& allocation, JSGlobalData* globalData, size_t cellSize)51 MarkedBlock::MarkedBlock(const PageAllocationAligned& allocation, Heap* heap, size_t cellSize) 52 52 : m_nextAtom(firstAtom()) 53 53 , m_allocation(allocation) 54 , m_heap( &globalData->heap)54 , m_heap(heap) 55 55 { 56 56 m_atomsPerCell = (cellSize + atomSize - 1) / atomSize; 57 57 m_endAtom = atomsPerBlock - m_atomsPerCell + 1; 58 58 59 Structure* dummyMarkableCellStructure = globalData->dummyMarkableCellStructure.get();59 Structure* dummyMarkableCellStructure = heap->globalData()->dummyMarkableCellStructure.get(); 60 60 for (size_t i = firstAtom(); i < m_endAtom; i += m_atomsPerCell) 61 new (&atoms()[i]) JSCell(* globalData, dummyMarkableCellStructure, JSCell::CreatingEarlyCell);61 new (&atoms()[i]) JSCell(*heap->globalData(), dummyMarkableCellStructure, JSCell::CreatingEarlyCell); 62 62 } 63 63 -
trunk/Source/JavaScriptCore/heap/MarkedBlock.h
r87522 r87653 32 32 class Heap; 33 33 class JSCell; 34 class JSGlobalData;35 34 36 35 typedef uintptr_t Bits; … … 45 44 static const size_t atomSize = sizeof(double); // Ensures natural alignment for all built-in types. 46 45 47 static MarkedBlock* create( JSGlobalData*, size_t cellSize);46 static MarkedBlock* create(Heap*, size_t cellSize); 48 47 static void destroy(MarkedBlock*); 49 48 … … 86 85 typedef char Atom[atomSize]; 87 86 88 MarkedBlock(const PageAllocationAligned&, JSGlobalData*, size_t cellSize);87 MarkedBlock(const PageAllocationAligned&, Heap*, size_t cellSize); 89 88 Atom* atoms(); 90 89 -
trunk/Source/JavaScriptCore/heap/MarkedSpace.cpp
r86974 r87653 24 24 #include "JSGlobalObject.h" 25 25 #include "JSCell.h" 26 #include "JSGlobalData.h"27 26 #include "JSLock.h" 28 27 #include "JSObject.h" … … 33 32 class Structure; 34 33 35 MarkedSpace::MarkedSpace( JSGlobalData* globalData)34 MarkedSpace::MarkedSpace(Heap* heap) 36 35 : m_waterMark(0) 37 36 , m_highWaterMark(0) 38 , m_ globalData(globalData)37 , m_heap(heap) 39 38 { 40 39 for (size_t cellSize = preciseStep; cellSize < preciseCutoff; cellSize += preciseStep) … … 57 56 MarkedBlock* MarkedSpace::allocateBlock(SizeClass& sizeClass) 58 57 { 59 MarkedBlock* block = MarkedBlock::create( globalData(), sizeClass.cellSize);58 MarkedBlock* block = MarkedBlock::create(m_heap, sizeClass.cellSize); 60 59 sizeClass.blockList.append(block); 61 60 sizeClass.nextBlock = block; … … 75 74 MarkedBlock::destroy(block); 76 75 } 77 }78 79 void* MarkedSpace::allocateFromSizeClass(SizeClass& sizeClass)80 {81 for (MarkedBlock*& block = sizeClass.nextBlock ; block; block = block->next()) {82 if (void* result = block->allocate())83 return result;84 85 m_waterMark += block->capacity();86 }87 88 if (m_waterMark < m_highWaterMark)89 return allocateBlock(sizeClass)->allocate();90 91 return 0;92 76 } 93 77 -
trunk/Source/JavaScriptCore/heap/MarkedSpace.h
r87522 r87653 39 39 class Heap; 40 40 class JSCell; 41 class JSGlobalData;42 41 class LiveObjectIterator; 43 42 class MarkStack; … … 48 47 WTF_MAKE_NONCOPYABLE(MarkedSpace); 49 48 public: 50 // Currently public for use in assertions.51 49 static const size_t maxCellSize = 1024; 52 50 53 static Heap* heap(JSCell*); 51 struct SizeClass { 52 SizeClass(); 53 void reset(); 54 54 55 static bool isMarked(const void*);56 static bool testAndSetMarked(const void*);57 static bool testAndClearMarked(const void*);58 static void setMarked(const void*);55 MarkedBlock* nextBlock; 56 DoublyLinkedList<MarkedBlock> blockList; 57 size_t cellSize; 58 }; 59 59 60 MarkedSpace( JSGlobalData*);60 MarkedSpace(Heap*); 61 61 void destroy(); 62 63 JSGlobalData* globalData();64 62 65 63 size_t highWaterMark(); 66 64 void setHighWaterMark(size_t); 67 65 68 void* allocate(size_t); 66 SizeClass& sizeClassFor(size_t); 67 void* allocate(SizeClass&); 69 68 70 69 void clearMarks(); … … 95 94 typedef HashSet<MarkedBlock*>::iterator BlockIterator; 96 95 97 struct SizeClass {98 SizeClass();99 void reset();100 101 MarkedBlock* nextBlock;102 DoublyLinkedList<MarkedBlock> blockList;103 size_t cellSize;104 };105 106 96 MarkedBlock* allocateBlock(SizeClass&); 107 97 void freeBlocks(DoublyLinkedList<MarkedBlock>&); 108 109 SizeClass& sizeClassFor(size_t);110 void* allocateFromSizeClass(SizeClass&);111 98 112 99 void clearMarks(MarkedBlock*); … … 117 104 size_t m_waterMark; 118 105 size_t m_highWaterMark; 119 JSGlobalData* m_globalData;106 Heap* m_heap; 120 107 }; 121 122 inline Heap* MarkedSpace::heap(JSCell* cell)123 {124 return MarkedBlock::blockFor(cell)->heap();125 }126 127 inline bool MarkedSpace::isMarked(const void* cell)128 {129 return MarkedBlock::blockFor(cell)->isMarked(cell);130 }131 132 inline bool MarkedSpace::testAndSetMarked(const void* cell)133 {134 return MarkedBlock::blockFor(cell)->testAndSetMarked(cell);135 }136 137 inline bool MarkedSpace::testAndClearMarked(const void* cell)138 {139 return MarkedBlock::blockFor(cell)->testAndClearMarked(cell);140 }141 142 inline void MarkedSpace::setMarked(const void* cell)143 {144 MarkedBlock::blockFor(cell)->setMarked(cell);145 }146 108 147 109 inline bool MarkedSpace::contains(const void* x) … … 164 126 } 165 127 166 inline JSGlobalData* MarkedSpace::globalData()167 {168 return m_globalData;169 }170 171 128 inline size_t MarkedSpace::highWaterMark() 172 129 { … … 187 144 } 188 145 189 inline void* MarkedSpace::allocate( size_t bytes)146 inline void* MarkedSpace::allocate(SizeClass& sizeClass) 190 147 { 191 SizeClass& sizeClass = sizeClassFor(bytes); 192 return allocateFromSizeClass(sizeClass); 148 for (MarkedBlock*& block = sizeClass.nextBlock ; block; block = block->next()) { 149 if (void* result = block->allocate()) 150 return result; 151 152 m_waterMark += block->capacity(); 153 } 154 155 if (m_waterMark < m_highWaterMark) 156 return allocateBlock(sizeClass)->allocate(); 157 158 return 0; 193 159 } 194 160 195 161 inline MarkedSpace::SizeClass::SizeClass() 196 162 : nextBlock(0)
Note: See TracChangeset
for help on using the changeset viewer.