Lines Matching full:heap
266 New heap for global handles.
307 * runtime/Heap.cpp:
308 (JSC::Heap::Heap):
309 (JSC::Heap::destroy):
310 (JSC::Heap::markRoots):
311 * runtime/Heap.h:
312 (JSC::Heap::allocateGlobalHandle):
313 (JSC::Heap::reportExtraMemoryCost):
602 A little more encapsulation for the heap: Removed CollectorHeapIterator
606 of the pieces of the heap. This undermines the encapsulation I'm trying
627 * runtime/Heap.cpp:
632 (JSC::Heap::protectedObjectTypeCounts):
633 (JSC::Heap::objectTypeCounts): Added forEach and removed iterator.
635 * runtime/Heap.h:
636 (JSC::Heap::forEach):
691 * runtime/Heap.cpp:
692 (JSC::Heap::allocate): Updated for removal of HeapConstants.
693 (JSC::Heap::reset): Updated to use size(), instead of calculating size
696 * runtime/Heap.h: Moved the ASSERT here to MarkedBlock, since it enforces
739 * runtime/Heap.cpp:
740 (JSC::Heap::markRoots):
741 (JSC::Heap::reset): Renamed clearMarkBits => clearMarks, since clients
822 * runtime/Heap.cpp:
823 (JSC::Heap::reset): Moved the call to shrink() here, since it seems a
1094 A tiny bit of encapsulation for MarkedBlock: made its heap data member private
1100 (JSC::MarkedBlock::heap): Made the heap data member private, and provided
1106 (JSC::MarkedSpace::heap): Use the constructor and accessor.
1135 Removed some dead code from Heap
1148 Use a vector to track blocks in the Heap, instead of hand-rolled vector-like code
1266 Removed some dead code from Heap
1432 Don't shrink the heap to 0 unconditionally. Instead, shrink to 1 if
1433 necessary. For now, the heap assumes that it always has at least one
1436 * runtime/Heap.cpp:
1437 (JSC::Heap::Heap):
1438 (JSC::Heap::reset):
1439 * runtime/Heap.h:
1553 * runtime/Heap.cpp:
1554 (JSC::Heap::Heap):
1555 (JSC::Heap::reset):
1556 * runtime/Heap.h:
1567 * runtime/Heap.cpp:
1568 (JSC::Heap::reset): Use an explicit cast to avoid shortening warnings,
1575 Changed MarkedSpace to delegate grow/shrink decisions to Heap
1580 * runtime/Heap.cpp:
1581 (JSC::Heap::Heap):
1582 (JSC::Heap::reset):
1583 * runtime/Heap.h: Reorganized a few data members for better cache locality.
1590 the heap to make an explicit sweep call.
1595 many bytes to allocate before failing and giving the heap an opportunity
1612 Not all blocks are freed when the heap is freed (counting is hard!)
1649 (JSC::MarkedSpace::heap):
1755 A little more Heap refactoring
1776 * runtime/Heap.cpp:
1778 * runtime/Heap.h:
1779 (JSC::Heap::isMarked):
1780 (JSC::Heap::testAndSetMarked):
1781 (JSC::Heap::setMarked):
1901 blocks on the Heap, instead of on independent global objects. The heap
1902 is guaranteed to outlast any GC-owned data structure. The heap is also
1904 the heap is responsible for marking all roots.
1906 * runtime/Heap.cpp:
1907 (JSC::Heap::markRoots):
1908 (JSC::Heap::globalObjectCount):
1909 (JSC::Heap::protectedGlobalObjectCount):
1910 * runtime/Heap.h:
1911 (JSC::Heap::codeBlocks):
1945 Skipping forward upon construction was causing the heap to skip running
1949 when the heap would destroy a block whose first object was a global
2220 * runtime/Heap.cpp:
2221 (JSC::Heap::markProtectedObjects):
2222 (JSC::Heap::markTempSortVectors):
2223 (JSC::Heap::markRoots):
2636 * runtime/Heap.cpp:
2637 (JSC::Heap::markProtectedObjects):
2638 (JSC::Heap::markTempSortVectors):
2639 (JSC::Heap::markRoots):
2953 * runtime/Heap.cpp:
2954 (JSC::Heap::markProtectedObjects):
2955 (JSC::Heap::markTempSortVectors):
2956 (JSC::Heap::markRoots):
3164 Filter all Heap collection through a common reset function, in
3170 * runtime/Heap.cpp:
3171 (JSC::Heap::reportExtraMemoryCostSlowCase): When we're over the extraCost
3173 way of resetting the heap. In theory, this may be slower in some cases,
3174 but it also fixes cases of pathological heap growth that we've seen,
3178 (JSC::Heap::allocate):
3179 (JSC::Heap::collectAllGarbage): Use the shared reset function.
3181 (JSC::Heap::reset):
3182 * runtime/Heap.h: Carved a new shared reset function out of the old
3268 Simplified Heap iteration
3287 (JSC::MarkedSpace::sweep): Always sweep from the beginning of the heap
3288 to the end, to avoid making sweep subtly reliant on internal Heap state.
3297 Simplified heap destruction
3301 * runtime/Heap.cpp:
3302 (JSC::Heap::destroy):
3303 * runtime/Heap.h:
3316 Switched heap to use the Bitmap class and removed CollectorBitmap
3338 Some more Heap cleanup.
3344 * runtime/Heap.cpp:
3345 (JSC::Heap::reportExtraMemoryCostSlowCase): Renamed recordExtraCost to
3348 (JSC::Heap::capacity): Renamed size to capacity because this function
3349 returns the capacity of the heap, including unused portions.
3351 * runtime/Heap.h:
3352 (JSC::Heap::globalData):
3353 (JSC::Heap::markedSpace):
3354 (JSC::Heap::machineStackMarker):
3355 (JSC::Heap::reportExtraMemoryCost): Moved statics to the top of the file.
3361 function returns the capacity of the heap, including unused portions.
3561 * runtime/Heap.cpp:
3562 (JSC::Heap::markProtectedObjects):
3563 (JSC::Heap::markTempSortVectors):
3564 (JSC::Heap::markRoots):
3928 * runtime/Heap.cpp:
3929 (JSC::Heap::markProtectedObjects):
3930 (JSC::Heap::markTempSortVectors):
3931 (JSC::Heap::markRoots):
4490 * runtime/Heap.cpp:
4491 (JSC::Heap::markRoots):
4512 (JSC::JSCell::Heap::heap):
4515 (JSC::MarkedSpace::heap):
4561 * runtime/Heap.cpp:
4562 (JSC::Heap::registerFile):
4563 (JSC::Heap::markRoots):
4564 * runtime/Heap.h:
4565 (JSC::Heap::contains): Migrated markConservatively() to the machine stack
4566 marker class. Now, Heap just provides a contains() function, which the
4567 machine stack marker uses for checking whether a pointer points into the heap.
4628 Moved the mark stack from global data to the heap, since it pertains
4629 to the heap, and not the virtual machine as a whole.
4634 * runtime/Heap.cpp:
4635 (JSC::Heap::Heap):
4636 (JSC::Heap::markRoots):
4637 * runtime/Heap.h:
4696 * runtime/Heap.cpp:
4697 (JSC::Heap::recordExtraCost): No need to guard against conservative
4701 (JSC::Heap::markConservatively):
4702 (JSC::Heap::markProtectedObjects):
4703 (JSC::Heap::markTempSortVectors): Don't drain the mark stack inside a
4707 (JSC::Heap::markRoots): Gather the set of conservative references before
4711 (JSC::Heap::collectAllGarbage): No need to guard against conservative
4715 * runtime/Heap.h: Updated to use the ConservativeSet API.
5254 * runtime/Heap.cpp:
5255 (JSC::Heap::Heap):
5261 * runtime/Heap.cpp:
5262 (JSC::Heap::markRoots):
5270 * runtime/Heap.cpp:
5271 (JSC::Heap::Heap):
5272 (JSC::Heap::markRoots): Kids, remember to initialize your data members.
5292 * runtime/Heap.cpp:
5298 Split out a MarkedSpace strategy object from Heap.
5311 * runtime/Heap.cpp:
5312 (JSC::Heap::Heap):
5313 (JSC::Heap::destroy):
5314 (JSC::Heap::recordExtraCost):
5315 (JSC::Heap::allocate):
5316 (JSC::Heap::markConservatively):
5317 (JSC::Heap::markRoots):
5318 (JSC::Heap::objectCount):
5319 (JSC::Heap::statistics):
5320 (JSC::Heap::size):
5321 (JSC::Heap::isBusy):
5322 (JSC::Heap::collectAllGarbage):
5323 (JSC::Heap::primaryHeapBegin):
5324 (JSC::Heap::primaryHeapEnd):
5325 * runtime/Heap.h:
5326 (JSC::Heap::globalData):
5327 (JSC::Heap::markedSpace):
5328 (JSC::Heap::isCellMarked):
5329 (JSC::Heap::checkMarkCell):
5330 (JSC::Heap::markCell): Moved all code pertaining to managing chunks of
5331 collector memory out of this class. Heap now just delegates to MarkedSpace.
5334 (JSC::JSCell::Heap::heap): Updated for MarkedSpace delegation.
5338 * runtime/MarkedSpace.cpp: Copied from runtime/Heap.cpp.
5358 * runtime/MarkedSpace.h: Copied from runtime/Heap.h.
5731 * runtime/Heap.cpp:
5732 (JSC::Heap::reset):
5733 (JSC::Heap::collectAllGarbage):
5754 Moved Collector.* => Heap.*, since the file contains a class named "Heap".
5771 * runtime/Heap.cpp: Copied from JavaScriptCore/runtime/Collector.cpp.
5772 * runtime/Heap.h: Copied from JavaScriptCore/runtime/Collector.h.
6378 (JSC::Heap::Heap):
6379 (JSC::Heap::destroy):
6380 (JSC::Heap::markRoots):
6382 (JSC::Heap::machineStackMarker): Moved code to machineStackMarker.
6386 level of indirection, to make Heap less of a God class.
6398 (JSC::MachineStackMarker::markMachineStackConservatively): Moved code from Heap.
7259 Heap::allocateBlock (1902752929), and some other leaks and crashes as well.
7272 (JSC::Heap::destroy):
7273 (JSC::Heap::allocateBlock):
7274 (JSC::Heap::freeBlock):
7275 (JSC::Heap::addWeakGCHandle):
7491 (JSC::Heap::registerThread):
7492 (JSC::Heap::markCurrentThreadConservativelyInternal):
7921 (JSC::Heap::addTempSortVector):
7922 (JSC::Heap::removeTempSortVector):
7923 (JSC::Heap::markTempSortVectors):
7924 (JSC::Heap::markRoots):
8091 (JSC::Heap::markConservatively):
8092 (JSC::Heap::markCurrentThreadConservativelyInternal):
8093 (JSC::Heap::markOtherThreadConservatively):
8527 com.apple.JavaScriptCore: JSC::Heap::markRoots + 746
8534 (JSC::Heap::activityCallback):
9630 (JSC::Heap::markRoots):
13142 Move big allocation in arrayProtoFuncToString from stack to heap.
14297 Crash due to timer triggered GC on one heap while another heap is active
14301 The GC timer may trigger for one heap while another heap is active. This
14303 thread's identifierTable with the heap we're collecting on. Otherwise we
14308 (JSC::Heap::allocate):
14309 (JSC::Heap::reset):
14310 (JSC::Heap::collectAllGarbage):
16968 (JSC::Heap::checkMarkCell):
17736 (JSC::Heap::destroy):
17737 (JSC::Heap::allocateBlock):
17738 (JSC::Heap::freeBlock):
17739 (JSC::Heap::updateWeakGCHandles):
17741 (JSC::Heap::addWeakGCHandle):
17742 (JSC::Heap::markRoots):
17744 (JSC::Heap::weakGCHandlePool):
18044 blocks of memory for the GC heap, instead of allocating RChunks. Revert this change in
18081 (JSC::Heap::allocateBlock):
18122 (JSC::Heap::markConservatively):
18167 (JSC::Heap::markConservatively):
18278 (JSC::Heap::Heap):
18279 (JSC::Heap::destroy):
18280 (JSC::Heap::allocateBlock):
18281 (JSC::Heap::freeBlock):
18282 (JSC::Heap::freeBlocks):
18283 (JSC::Heap::allocate):
18284 (JSC::Heap::shrinkBlocks):
18285 (JSC::Heap::markConservatively):
18286 (JSC::Heap::clearMarkBits):
18287 (JSC::Heap::markedCells):
18443 in the heap, so the JSArray constructor can't safely call Heap::heap().
18524 allocation causes the heap to reset. This is useful for adding a
18540 (JSC::Heap::Heap):
18541 (JSC::Heap::reset):
18542 (JSC::Heap::setActivityCallback):
20620 (JSC::Heap::freeBlocks):
20654 (JSC::Heap::freeBlocks):
21207 (JSC::Heap::allocateBlock):
21208 (JSC::Heap::allocate):
21320 (JSC::Heap::allocateBlock):
24355 (JSC::Heap::allocate):
