Changeset 124250 in webkit
- Timestamp:
- Jul 31, 2012 2:26:38 PM (12 years ago)
- Location:
- trunk/Source/JavaScriptCore
- Files:
-
- 12 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/Source/JavaScriptCore/ChangeLog
r124230 r124250 1 2012-07-31 Geoffrey Garen <ggaren@apple.com> 2 3 Removed some public data and casting from the Heap 4 https://bugs.webkit.org/show_bug.cgi?id=92777 5 6 Reviewed by Oliver Hunt. 7 8 * heap/BlockAllocator.cpp: 9 (JSC::BlockAllocator::releaseFreeBlocks): 10 (JSC::BlockAllocator::blockFreeingThreadMain): Use the DeadBlock class 11 since HeapBlock is a template, and not a class, now. Call destroy() 12 instead of monkeying around with DeadBlock's internal data because 13 encapsulation is good. 14 15 * heap/BlockAllocator.h: 16 (DeadBlock): Added a class to represent a dead block, since HeapBlock is 17 a template now, and can't be instantiated directly. 18 19 (JSC::DeadBlock::DeadBlock): 20 (JSC::DeadBlock::create): 21 (BlockAllocator): 22 (JSC::BlockAllocator::allocate): 23 (JSC::BlockAllocator::deallocate): Use the DeadBlock class because 24 encapsulation is good. 25 26 * heap/CopiedBlock.h: 27 (CopiedBlock::destroy): No need for a destroy() function, since we 28 inherit one now. 29 30 (JSC::CopiedBlock::CopiedBlock): 31 (JSC::CopiedBlock::payloadEnd): 32 (JSC::CopiedBlock::capacity): Updated for some encapsulation inside 33 HeapBlock. 34 35 * heap/CopiedSpace.cpp: 36 (JSC::CopiedSpace::~CopiedSpace): 37 (JSC::CopiedSpace::doneCopying): 38 (JSC::CopiedSpace::size): 39 (JSC::CopiedSpace::capacity): 40 (JSC::isBlockListPagedOut): Removed a bunch of casting. This is no longer 41 necessary, now that our list and its nodes have the right type. 42 43 * heap/CopiedSpace.h: Use the right type in our data structures because 44 it improves clarity. 45 46 * heap/CopiedSpaceInlineMethods.h: 47 (JSC::CopiedSpace::startedCopying): Use swap to avoid duplicating it. 48 49 * heap/HeapBlock.h: 50 (HeapBlock): Made this a class template so we can return the right type 51 in linked list operations. Made our data private because encapsulation 52 is good. 53 54 (JSC::HeapBlock::destroy): Since we know our type, we can also eliminate 55 duplicate destroy() functions in our subclasses. 56 57 (JSC::HeapBlock::allocation): Added an accessor so we can hide our data. 58 By using const, this accessor prevents clients from accidentally deleting 59 our allocation. 60 61 * heap/MarkedAllocator.cpp: 62 (JSC::MarkedAllocator::isPagedOut): 63 (JSC::MarkedAllocator::tryAllocateHelper): 64 (JSC::MarkedAllocator::removeBlock): Removed a bunch of casting. This is 65 no longer necessary, now that our list and its nodes have the right type. 66 67 * heap/MarkedAllocator.h: 68 (MarkedAllocator): 69 (JSC::MarkedAllocator::reset): 70 (JSC::MarkedAllocator::forEachBlock): Use the right type, do less casting. 71 72 * heap/MarkedBlock.cpp: 73 (JSC::MarkedBlock::destroy): Removed this function because our parent 74 class provides it for us now. 75 76 (JSC::MarkedBlock::MarkedBlock): 77 * heap/MarkedBlock.h: 78 (MarkedBlock): 79 (JSC::MarkedBlock::capacity): Updated for encapsulation. 80 1 81 2012-07-31 Filip Pizlo <fpizlo@apple.com> 2 82 -
trunk/Source/JavaScriptCore/heap/BlockAllocator.cpp
r120149 r124250 56 56 { 57 57 while (true) { 58 HeapBlock* block;58 DeadBlock* block; 59 59 { 60 60 SpinLockHolder locker(&m_freeBlockLock); … … 71 71 break; 72 72 73 block->m_allocation.deallocate();73 DeadBlock::destroy(block).deallocate(); 74 74 } 75 75 } … … 122 122 123 123 while (!m_blockFreeingThreadShouldQuit) { 124 HeapBlock* block;124 DeadBlock* block; 125 125 { 126 126 SpinLockHolder locker(&m_freeBlockLock); … … 137 137 break; 138 138 139 block->m_allocation.deallocate();139 DeadBlock::destroy(block).deallocate(); 140 140 } 141 141 } -
trunk/Source/JavaScriptCore/heap/BlockAllocator.h
r120149 r124250 39 39 // short periods of time and then freeing them on a secondary thread. 40 40 41 class DeadBlock : public HeapBlock<DeadBlock> { 42 public: 43 static DeadBlock* create(const PageAllocationAligned&); 44 45 private: 46 DeadBlock(const PageAllocationAligned&); 47 }; 48 49 inline DeadBlock::DeadBlock(const PageAllocationAligned& allocation) 50 : HeapBlock<DeadBlock>(allocation) 51 { 52 } 53 54 inline DeadBlock* DeadBlock::create(const PageAllocationAligned& allocation) 55 { 56 return new(NotNull, allocation.base()) DeadBlock(allocation); 57 } 58 41 59 class BlockAllocator { 42 60 public: … … 56 74 void releaseFreeBlocks(); 57 75 58 DoublyLinkedList< HeapBlock> m_freeBlocks;76 DoublyLinkedList<DeadBlock> m_freeBlocks; 59 77 size_t m_numberOfFreeBlocks; 60 78 bool m_isCurrentlyAllocating; … … 74 92 ASSERT(!m_freeBlocks.isEmpty()); 75 93 m_numberOfFreeBlocks--; 76 return m_freeBlocks.removeHead()->m_allocation;94 return DeadBlock::destroy(m_freeBlocks.removeHead()); 77 95 } 78 96 } 79 97 80 98 ASSERT(m_freeBlocks.isEmpty()); 81 PageAllocationAligned allocation = PageAllocationAligned::allocate( HeapBlock::s_blockSize, HeapBlock::s_blockSize, OSAllocator::JSGCHeapPages);99 PageAllocationAligned allocation = PageAllocationAligned::allocate(DeadBlock::s_blockSize, DeadBlock::s_blockSize, OSAllocator::JSGCHeapPages); 82 100 if (!static_cast<bool>(allocation)) 83 101 CRASH(); … … 88 106 { 89 107 SpinLockHolder locker(&m_freeBlockLock); 90 HeapBlock* heapBlock = new(NotNull, allocation.base()) HeapBlock(allocation); 91 m_freeBlocks.push(heapBlock); 108 m_freeBlocks.push(DeadBlock::create(allocation)); 92 109 m_numberOfFreeBlocks++; 93 110 } -
trunk/Source/JavaScriptCore/heap/CopiedBlock.h
r122677 r124250 35 35 class CopiedSpace; 36 36 37 class CopiedBlock : public HeapBlock {37 class CopiedBlock : public HeapBlock<CopiedBlock> { 38 38 friend class CopiedSpace; 39 39 friend class CopiedAllocator; … … 41 41 static CopiedBlock* create(const PageAllocationAligned&); 42 42 static CopiedBlock* createNoZeroFill(const PageAllocationAligned&); 43 static PageAllocationAligned destroy(CopiedBlock*);44 43 45 44 // The payload is the region of the block that is usable for allocations. … … 94 93 } 95 94 96 inline PageAllocationAligned CopiedBlock::destroy(CopiedBlock* block)97 {98 PageAllocationAligned allocation;99 swap(allocation, block->m_allocation);100 101 block->~CopiedBlock();102 return allocation;103 }104 105 95 inline CopiedBlock::CopiedBlock(const PageAllocationAligned& allocation) 106 : HeapBlock (allocation)96 : HeapBlock<CopiedBlock>(allocation) 107 97 , m_remaining(payloadCapacity()) 108 98 , m_isPinned(false) … … 118 108 inline char* CopiedBlock::payloadEnd() 119 109 { 120 return reinterpret_cast<char*>(this) + m_allocation.size();110 return reinterpret_cast<char*>(this) + allocation().size(); 121 111 } 122 112 … … 163 153 inline size_t CopiedBlock::capacity() 164 154 { 165 return m_allocation.size();155 return allocation().size(); 166 156 } 167 157 -
trunk/Source/JavaScriptCore/heap/CopiedSpace.cpp
r122677 r124250 45 45 { 46 46 while (!m_toSpace->isEmpty()) 47 m_heap->blockAllocator().deallocate(CopiedBlock::destroy( static_cast<CopiedBlock*>(m_toSpace->removeHead())));47 m_heap->blockAllocator().deallocate(CopiedBlock::destroy(m_toSpace->removeHead())); 48 48 49 49 while (!m_fromSpace->isEmpty()) 50 m_heap->blockAllocator().deallocate(CopiedBlock::destroy( static_cast<CopiedBlock*>(m_fromSpace->removeHead())));50 m_heap->blockAllocator().deallocate(CopiedBlock::destroy(m_fromSpace->removeHead())); 51 51 52 52 while (!m_oversizeBlocks.isEmpty()) 53 CopiedBlock::destroy( static_cast<CopiedBlock*>(m_oversizeBlocks.removeHead())).deallocate();53 CopiedBlock::destroy(m_oversizeBlocks.removeHead()).deallocate(); 54 54 } 55 55 … … 194 194 m_inCopyingPhase = false; 195 195 while (!m_fromSpace->isEmpty()) { 196 CopiedBlock* block = static_cast<CopiedBlock*>(m_fromSpace->removeHead());196 CopiedBlock* block = m_fromSpace->removeHead(); 197 197 if (block->m_isPinned) { 198 198 block->m_isPinned = false; … … 208 208 } 209 209 210 CopiedBlock* curr = static_cast<CopiedBlock*>(m_oversizeBlocks.head());210 CopiedBlock* curr = m_oversizeBlocks.head(); 211 211 while (curr) { 212 CopiedBlock* next = static_cast<CopiedBlock*>(curr->next());212 CopiedBlock* next = curr->next(); 213 213 if (!curr->m_isPinned) { 214 214 m_oversizeBlocks.remove(curr); … … 225 225 allocateBlock(); 226 226 else 227 m_allocator.setCurrentBlock( static_cast<CopiedBlock*>(m_toSpace->head()));227 m_allocator.setCurrentBlock(m_toSpace->head()); 228 228 } 229 229 … … 232 232 size_t calculatedSize = 0; 233 233 234 for (CopiedBlock* block = static_cast<CopiedBlock*>(m_toSpace->head()); block; block = static_cast<CopiedBlock*>(block->next()))234 for (CopiedBlock* block = m_toSpace->head(); block; block = block->next()) 235 235 calculatedSize += block->size(); 236 236 237 for (CopiedBlock* block = static_cast<CopiedBlock*>(m_fromSpace->head()); block; block = static_cast<CopiedBlock*>(block->next()))237 for (CopiedBlock* block = m_fromSpace->head(); block; block = block->next()) 238 238 calculatedSize += block->size(); 239 239 240 for (CopiedBlock* block = static_cast<CopiedBlock*>(m_oversizeBlocks.head()); block; block = static_cast<CopiedBlock*>(block->next()))240 for (CopiedBlock* block = m_oversizeBlocks.head(); block; block = block->next()) 241 241 calculatedSize += block->size(); 242 242 … … 248 248 size_t calculatedCapacity = 0; 249 249 250 for (CopiedBlock* block = static_cast<CopiedBlock*>(m_toSpace->head()); block; block = static_cast<CopiedBlock*>(block->next()))250 for (CopiedBlock* block = m_toSpace->head(); block; block = block->next()) 251 251 calculatedCapacity += block->capacity(); 252 252 253 for (CopiedBlock* block = static_cast<CopiedBlock*>(m_fromSpace->head()); block; block = static_cast<CopiedBlock*>(block->next()))253 for (CopiedBlock* block = m_fromSpace->head(); block; block = block->next()) 254 254 calculatedCapacity += block->capacity(); 255 255 256 for (CopiedBlock* block = static_cast<CopiedBlock*>(m_oversizeBlocks.head()); block; block = static_cast<CopiedBlock*>(block->next()))256 for (CopiedBlock* block = m_oversizeBlocks.head(); block; block = block->next()) 257 257 calculatedCapacity += block->capacity(); 258 258 … … 260 260 } 261 261 262 static bool isBlockListPagedOut(double deadline, DoublyLinkedList< HeapBlock>* list)262 static bool isBlockListPagedOut(double deadline, DoublyLinkedList<CopiedBlock>* list) 263 263 { 264 264 unsigned itersSinceLastTimeCheck = 0; 265 HeapBlock* current = list->head();265 CopiedBlock* current = list->head(); 266 266 while (current) { 267 267 current = current->next(); -
trunk/Source/JavaScriptCore/heap/CopiedSpace.h
r123417 r124250 45 45 class Heap; 46 46 class CopiedBlock; 47 class HeapBlock;48 47 49 48 class CopiedSpace { … … 102 101 SpinLock m_toSpaceLock; 103 102 104 DoublyLinkedList< HeapBlock>* m_toSpace;105 DoublyLinkedList< HeapBlock>* m_fromSpace;103 DoublyLinkedList<CopiedBlock>* m_toSpace; 104 DoublyLinkedList<CopiedBlock>* m_fromSpace; 106 105 107 DoublyLinkedList< HeapBlock> m_blocks1;108 DoublyLinkedList< HeapBlock> m_blocks2;109 DoublyLinkedList< HeapBlock> m_oversizeBlocks;106 DoublyLinkedList<CopiedBlock> m_blocks1; 107 DoublyLinkedList<CopiedBlock> m_blocks2; 108 DoublyLinkedList<CopiedBlock> m_oversizeBlocks; 110 109 111 110 bool m_inCopyingPhase; … … 117 116 static const size_t s_maxAllocationSize = 32 * KB; 118 117 static const size_t s_initialBlockNum = 16; 119 static const size_t s_blockMask = ~( HeapBlock::s_blockSize - 1);118 static const size_t s_blockMask = ~(CopiedBlock::s_blockSize - 1); 120 119 }; 121 120 -
trunk/Source/JavaScriptCore/heap/CopiedSpaceInlineMethods.h
r123417 r124250 96 96 inline void CopiedSpace::startedCopying() 97 97 { 98 DoublyLinkedList<HeapBlock>* temp = m_fromSpace; 99 m_fromSpace = m_toSpace; 100 m_toSpace = temp; 98 std::swap(m_fromSpace, m_toSpace); 101 99 102 100 m_blockFilter.reset(); -
trunk/Source/JavaScriptCore/heap/HeapBlock.h
r118083 r124250 35 35 enum AllocationEffort { AllocationCanFail, AllocationMustSucceed }; 36 36 37 class HeapBlock : public DoublyLinkedListNode<HeapBlock> { 37 template<typename T> 38 class HeapBlock : public DoublyLinkedListNode<T> { 39 friend class DoublyLinkedListNode<T>; 38 40 public: 41 static const size_t s_blockSize = 64 * KB; 42 43 static PageAllocationAligned destroy(HeapBlock* block) 44 { 45 static_cast<T*>(block)->~T(); 46 47 PageAllocationAligned allocation; 48 std::swap(allocation, block->m_allocation); 49 return allocation; 50 } 51 39 52 HeapBlock(const PageAllocationAligned& allocation) 40 : DoublyLinkedListNode<HeapBlock>() 53 : DoublyLinkedListNode<T>() 54 , m_allocation(allocation) 41 55 , m_prev(0) 42 56 , m_next(0) 43 , m_allocation(allocation)44 57 { 45 58 ASSERT(m_allocation); 46 59 } 47 60 48 HeapBlock* m_prev; 49 HeapBlock* m_next; 61 const PageAllocationAligned allocation() const { return m_allocation; } 62 63 private: 50 64 PageAllocationAligned m_allocation; 51 52 static const size_t s_blockSize = 64 * KB;65 T* m_prev; 66 T* m_next; 53 67 }; 54 68 -
trunk/Source/JavaScriptCore/heap/MarkedAllocator.cpp
r124141 r124250 12 12 { 13 13 unsigned itersSinceLastTimeCheck = 0; 14 HeapBlock* block = m_blockList.head();14 MarkedBlock* block = m_blockList.head(); 15 15 while (block) { 16 16 block = block->next(); … … 30 30 { 31 31 if (!m_freeList.head) { 32 for (MarkedBlock*& block = m_blocksToSweep; block; block = static_cast<MarkedBlock*>(block->next())) {32 for (MarkedBlock*& block = m_blocksToSweep; block; block = block->next()) { 33 33 m_freeList = block->sweep(MarkedBlock::SweepToFreeList); 34 34 if (m_freeList.head) { … … 116 116 { 117 117 if (m_currentBlock == block) { 118 m_currentBlock = static_cast<MarkedBlock*>(m_currentBlock->next());118 m_currentBlock = m_currentBlock->next(); 119 119 m_freeList = MarkedBlock::FreeList(); 120 120 } 121 121 if (m_blocksToSweep == block) 122 m_blocksToSweep = static_cast<MarkedBlock*>(m_blocksToSweep->next());122 m_blocksToSweep = m_blocksToSweep->next(); 123 123 m_blockList.remove(block); 124 124 } -
trunk/Source/JavaScriptCore/heap/MarkedAllocator.h
r124141 r124250 48 48 MarkedBlock* m_currentBlock; 49 49 MarkedBlock* m_blocksToSweep; 50 DoublyLinkedList< HeapBlock> m_blockList;50 DoublyLinkedList<MarkedBlock> m_blockList; 51 51 size_t m_cellSize; 52 52 bool m_cellsNeedDestruction; … … 91 91 m_currentBlock = 0; 92 92 m_freeList = MarkedBlock::FreeList(); 93 m_blocksToSweep = static_cast<MarkedBlock*>(m_blockList.head());93 m_blocksToSweep = m_blockList.head(); 94 94 } 95 95 … … 107 107 template <typename Functor> inline void MarkedAllocator::forEachBlock(Functor& functor) 108 108 { 109 HeapBlock* next;110 for ( HeapBlock* block = m_blockList.head(); block; block = next) {109 MarkedBlock* next; 110 for (MarkedBlock* block = m_blockList.head(); block; block = next) { 111 111 next = block->next(); 112 functor( static_cast<MarkedBlock*>(block));112 functor(block); 113 113 } 114 114 } -
trunk/Source/JavaScriptCore/heap/MarkedBlock.cpp
r124141 r124250 38 38 } 39 39 40 PageAllocationAligned MarkedBlock::destroy(MarkedBlock* block)41 {42 PageAllocationAligned allocation;43 swap(allocation, block->m_allocation);44 45 block->~MarkedBlock();46 return allocation;47 }48 49 40 MarkedBlock::MarkedBlock(const PageAllocationAligned& allocation, Heap* heap, size_t cellSize, bool cellsNeedDestruction, bool onlyContainsStructures) 50 : HeapBlock (allocation)41 : HeapBlock<MarkedBlock>(allocation) 51 42 , m_atomsPerCell((cellSize + atomSize - 1) / atomSize) 52 43 , m_endAtom(atomsPerBlock - m_atomsPerCell + 1) -
trunk/Source/JavaScriptCore/heap/MarkedBlock.h
r123813 r124250 68 68 // size. 69 69 70 class MarkedBlock : public HeapBlock { 71 friend class WTF::DoublyLinkedListNode<MarkedBlock>; 70 class MarkedBlock : public HeapBlock<MarkedBlock> { 72 71 public: 73 72 // Ensure natural alignment for native types whilst recognizing that the smallest … … 115 114 116 115 static MarkedBlock* create(const PageAllocationAligned&, Heap*, size_t cellSize, bool cellsNeedDestruction, bool onlyContainsStructures); 117 static PageAllocationAligned destroy(MarkedBlock*);118 116 119 117 static bool isAtomAligned(const void*); … … 337 335 inline size_t MarkedBlock::capacity() 338 336 { 339 return m_allocation.size();337 return allocation().size(); 340 338 } 341 339
Note: See TracChangeset
for help on using the changeset viewer.