Lines Matching full:heap
43 // TODO(isolates): remove HEAP here
44 #define HEAP (_inline_get_heap_())
45 class Heap;
46 inline Heap* _inline_get_heap_();
49 // Defines all the roots in Heap.
240 typedef String* (*ExternalStringTableUpdaterCallback)(Heap* heap,
243 typedef bool (*DirtyRegionCallback)(Heap* heap,
249 // The all static Heapheap.
250 // All JavaScript contexts by this process share the same object heap.
307 friend class Heap;
321 Heap* heap_;
327 class Heap {
329 // Configure heap size before setup. Return false if the heap has been
336 // Initializes the global object heap. If create_heap_objects is true,
341 // Destroys all memory allocated by the heap.
352 // Returns the maximum amount of memory reserved for the heap. For
366 // Returns the capacity of the heap in bytes w/o growing. Heap grows when
370 // Returns the amount of memory currently committed for the heap.
373 // Returns the amount of executable memory currently committed for the heap.
377 // Heap doesn't guarantee that it can allocate an object that requires
384 // Returns of size of all objects residing in the heap.
421 // Protect/unprotect the heap by marking all spaces read-only/writable.
465 // Allocates a heap object based on the map.
471 // Allocates a JS Map in the heap.
745 // resource that resides outside the V8 heap.
767 // Initialize a filler object to keep the ability to iterate over the heap
842 // Notify the heap that a context has been disposed.
873 // Heap root getters. We have versions with and without type::cast() here.
908 // Iterates over all roots in the heap.
910 // Iterates over all strong roots in the heap.
912 // Iterates over all the other roots in the heap.
952 static bool IteratePointersInDirtyRegion(Heap* heap,
961 static bool IteratePointersInDirtyMapsRegion(Heap* heap,
972 // Checks whether an address/object in the heap (including auxiliary
978 // Currently used by tests, serialization and heap verification only.
1022 // Verify the heap is in its normal state before or after a GC.
1025 // Report heap statistics.
1034 // Print short heap statistics.
1073 // Callback function passed to Heap::Iterate etc. Copies an object if
1075 // ensure the precondition that the object is (a) a heap object and (b) in
1076 // the heap's from space.
1247 Heap();
1249 // This can be calculated directly from a pointer to the heap; however, it is
1250 // more expedient to get at the isolate directly from within Heap methods.
1430 // to Heap::AllocateRaw(size_in_bytes, MAP_SPACE), except that (a) it doesn't
1466 Heap* heap,
1471 // Performs a major collection in the whole heap.
1592 // Flag is set when the heap has been configured. The heap can be repeatedly
1610 DISALLOW_COPY_AND_ASSIGN(Heap);
1654 ASSERT(HEAP->always_allocate_scope_depth_ == 0);
1655 HEAP->always_allocate_scope_depth_++;
1659 HEAP->always_allocate_scope_depth_--;
1660 ASSERT(HEAP->always_allocate_scope_depth_ == 0);
1668 HEAP->linear_allocation_scope_depth_++;
1672 HEAP->linear_allocation_scope_depth_--;
1673 ASSERT(HEAP->linear_allocation_scope_depth_ >= 0);
1680 // or care about intergenerational references. All heap object pointers have to
1681 // point into the heap to a location that has a map pointer at its first word.
1682 // Caveat: Heap::Contains is an approximation because it can return true for
1683 // objects in a heap space but above the allocation pointer.
1690 ASSERT(HEAP->Contains(object));
1708 ASSERT(HEAP->Contains(object));
1710 if (HEAP->InNewSpace(object)) {
1711 ASSERT(HEAP->InToSpace(object));
1722 // Space iterator for iterating over all spaces of the heap.
1733 // Space iterator for iterating over all old spaces of the heap: Old pointer
1745 // Space iterator for iterating over all the paged spaces of the heap:
1757 // Space iterator for iterating over all spaces of the heap.
1778 // A HeapIterator provides iteration over the whole heap. It
1782 // HeapIterator can skip free list nodes (that is, de-allocated heap
1783 // objects that still remain in the heap). As implementation of free
1786 // as this will leave heap objects marked (and thus, unusable).
1950 old_state_ = HEAP->disallow_allocation_failure_;
1951 HEAP->disallow_allocation_failure_ = true;
1954 HEAP->disallow_allocation_failure_ = old_state_;
1963 old_state_ = HEAP->allow_allocation(false);
1967 HEAP->allow_allocation(old_state_);
1977 old_state_ = HEAP->allow_allocation(true);
1981 HEAP->allow_allocation(old_state_);
2038 explicit GCTracer(Heap* heap);
2068 // Returns size of object in heap (in MB).
2070 return (static_cast<double>(HEAP->SizeOfObjects())) / MB;
2074 intptr_t start_size_; // Size of objects in heap set in constructor.
2108 // Difference between space used in the heap at the beginning of the current
2119 Heap* heap_;
2129 // Returns a heap number with f(input), where f is a math function specified
2270 #undef HEAP
