Lines Matching full:heap
40 // Heap structures:
42 // A JS heap consists of a young generation, an old generation, and a large
54 // have the allocation top address of this page. Heap objects are aligned to the
70 // pointers without decoding heap object maps so if the page belongs to old
73 // aligned word which satisfies the Heap::InNewSpace() predicate must be a
74 // pointer to a live heap object in new space. Thus objects in old pointer
291 static inline void FlipMeaningOfInvalidatedWatermarkFlag(Heap* heap);
354 Heap* heap_;
362 Space(Heap* heap, AllocationSpace id, Executability executable)
363 : heap_(heap), id_(id), executable_(executable) {}
367 Heap* heap() const { return heap_; }
401 Heap* heap_;
408 // All heap objects containing executable code (code objects) must be allocated
419 // Can only be called once, at heap initialization time.
482 // allocator manages chunks for the paged heap spaces (old space and map
578 // but keep track of allocated bytes as part of heap.
661 // If a chunk has at least 16 pages, the maximum heap size is about
780 // Interface for heap object iterator to be implemented by all object space
796 // Heap
1023 PagedSpace(Heap* heap,
1317 explicit SemiSpace(Heap* heap) : Space(heap, NEW_SPACE, NOT_EXECUTABLE) {
1325 // Tear down the space. Heap memory was not allocated by the space, so it
1363 // True if the object is a heap object in the address range of this
1434 // semispace of the heap's new space. It iterates over the objects in the
1484 explicit NewSpace(Heap* heap)
1485 : Space(heap, NEW_SPACE, NOT_EXECUTABLE),
1486 to_space_(heap),
1487 from_space_(heap) {}
1492 // Tears down the space. Heap memory was not allocated by the space, so it
1610 // True if the object is a heap object in the address range of the
1647 // Record the allocation or promotion of a heap object. Note that we don't
1701 // Free-list nodes are free blocks in the heap. They look like heap objects
1702 // (free-list node pointers have the heap object tag, and they have a map like
1703 // a heap object). They have a size and a next pointer. The next pointer is
1718 // looks like a heap object to the garbage collector and heap iteration
1720 void set_size(Heap* heap, int size_in_bytes);
1723 inline Address next(Heap* heap);
1724 inline void set_next(Heap* heap, Address next);
1736 OldSpaceFreeList(Heap* heap, AllocationSpace owner);
1766 Heap* heap_;
1842 FixedSizeFreeList(Heap* heap, AllocationSpace owner, int object_size);
1864 Heap* heap_;
1893 OldSpace(Heap* heap,
1897 : PagedSpace(heap, max_capacity, id, executable),
1898 free_list_(heap, id) {
1967 FixedSpace(Heap* heap,
1972 : PagedSpace(heap, max_capacity, id, NOT_EXECUTABLE),
1975 free_list_(heap, id, object_size_in_bytes) {
2046 MapSpace(Heap* heap,
2050 : FixedSpace(heap, max_capacity, id, Map::kSize, "map"),
2160 CellSpace(Heap* heap, intptr_t max_capacity, AllocationSpace id)
2161 : FixedSpace(heap, max_capacity, id, JSGlobalPropertyCell::kSize, "cell")
2176 // the large object space. A large object is allocated from OS heap with
2237 LargeObjectSpace(Heap* heap, AllocationSpace id);
2283 // Checks whether a heap object is in this space; O(1).
