Lines Matching full:heap
48 // Defines all the roots in Heap.
255 typedef String* (*ExternalStringTableUpdaterCallback)(Heap* heap,
280 // The all static Heap captures the interface to the global object heap.
281 // All JavaScript contexts by this process share the same object heap.
292 explicit PromotionQueue(Heap* heap)
297 heap_(heap) { }
376 Heap* heap_;
409 friend class Heap;
423 Heap* heap_;
434 class Heap {
436 // Configure heap size before setup. Return false if the heap has been
443 // Initializes the global object heap. If create_heap_objects is true,
448 // Destroys all memory allocated by the heap.
459 // Returns the maximum amount of memory reserved for the heap. For
473 // Returns the capacity of the heap in bytes w/o growing. Heap grows when
477 // Returns the amount of memory currently committed for the heap.
480 // Returns the amount of executable memory currently committed for the heap.
484 // Heap doesn't guarantee that it can allocate an object that requires
488 // Returns of size of all objects residing in the heap.
608 // Allocates a heap object based on the map.
614 // Allocates a JS Map in the heap.
945 // resource that resides outside the V8 heap.
967 // Initialize a filler object to keep the ability to iterate over the heap
1047 // Making the heap iterable requires us to sweep precisely and abort any
1053 // non-zero, then the slower precise sweeper is used, which leaves the heap
1054 // in a state where we can iterate over the heap visiting all objects.
1060 // Check whether the heap is currently iterable.
1067 // Notify the heap that a context has been disposed.
1112 // Heap root getters. We have versions with and without type::cast() here.
1152 // Iterates over all roots in the heap.
1154 // Iterates over all strong roots in the heap.
1156 // Iterates over all the other roots in the heap.
1172 // Checks whether an address/object in the heap (including auxiliary
1178 // Currently used by tests, serialization and heap verification only.
1230 // Verify the heap is in its normal state before or after a GC.
1241 // Report heap statistics.
1249 // Print short heap statistics.
1289 // Callback function passed to Heap::Iterate etc. Copies an object if
1291 // ensure the precondition that the object is (a) a heap object and (b) in
1292 // the heap's from space.
1359 // heap and set the limits for the next GC accordingly. As we sweep we find
1361 // downwards the size of the heap. This means the limits that control the
1602 Heap();
1604 // This can be calculated directly from a pointer to the heap; however, it is
1605 // more expedient to get at the isolate directly from within Heap methods.
1807 // to Heap::AllocateRaw(size_in_bytes, MAP_SPACE), except that (a) it doesn't
1849 Heap* heap,
1853 static void ScavengeStoreBufferCallback(Heap* heap,
1857 // Performs a major collection in the whole heap.
1989 // Rough estimate of how many megabytes of heap can be processed in 1 ms.
2043 // Flag is set when the heap has been configured. The heap can be repeatedly
2064 DISALLOW_COPY_AND_ASSIGN(Heap);
2117 // or care about intergenerational references. All heap object pointers have to
2118 // point into the heap to a location that has a map pointer at its first word.
2119 // Caveat: Heap::Contains is an approximation because it can return true for
2120 // objects in a heap space but above the allocation pointer.
2128 // Space iterator for iterating over all spaces of the heap.
2139 // Space iterator for iterating over all old spaces of the heap: Old pointer
2151 // Space iterator for iterating over all the paged spaces of the heap:
2163 // Space iterator for iterating over all spaces of the heap.
2184 // A HeapIterator provides iteration over the whole heap. It
2188 // HeapIterator can skip free list nodes (that is, de-allocated heap
2189 // objects that still remain in the heap). As implementation of free
2192 // as this will leave heap objects marked (and thus, unusable).
2431 explicit GCTracer(Heap* heap,
2453 // Returns size of object in heap (in MB).
2459 // Size of objects in heap set in constructor.
2482 // Difference between space used in the heap at the beginning of the current
2500 Heap* heap_;
2510 static void Enter(Heap* heap,
2534 // Returns a heap number with f(input), where f is a math function specified
2615 // heap object's map word to mark objects.
