Lines Matching defs:heap
15 // Clients of this interface shouldn't depend on lots of heap internals.
16 // Do not include anything from src/heap here!
18 #include "include/v8-embedder-heap.h"
28 #include "src/heap/allocation-observer.h"
29 #include "src/heap/allocation-result.h"
30 #include "src/heap/heap-allocator.h"
31 #include "src/init/heap-symbols.h"
35 #include "src/objects/heap-object.h"
52 namespace heap {
55 } // namespace heap
249 DevToolsTraceEventScope(Heap* heap, const char* event_name,
332 // should instead adapt it's heap size based on available physical memory.
337 // The heap limit needs to be computed based on the system pointer size
338 // because we want a pointer-compressed heap to have larger limit than
346 // These constants control heap configuration based on the physical memory.
378 // The minimum size of a HeapObject on the heap.
414 // Zapping is needed for verify heap, and always done in debug builds.
494 // Notifies the heap that is ok to start marking or other activities that
522 // Initialize a filler object to keep the ability to iterate over the heap
554 // Notify the heap that a context has been disposed.
602 // Print short heap statistics.
611 // Dump heap statistics in JSON format.
759 // We can only invoke Safepoint() on the main thread local heap after
801 // Prepares the heap, setting up for deserialization.
804 // Sets read-only heap and space.
809 // Sets up the heap memory without creating any objects.
813 // Prepares the heap, setting up for deserialization.
822 // Bootstraps the object heap with the core set of objects required to run.
832 // Destroys all memory allocated by the heap.
928 // this is always a copy of the full builtin, i.e. not the off-heap
996 // Performs garbage collection operation for the shared heap.
1022 // (de)serialization or heap verification.
1149 // Embedder heap tracer support. =============================================
1164 // Unified heap (C++) support. ===============================================
1199 Heap* heap, FullObjectSlot pointer);
1219 // Checks whether an address/object is in the non-read-only heap (including
1227 // Checks whether an address/object is in the non-read-only heap (including
1236 // Currently used by tests, serialization and heap verification only.
1239 // Returns true when this heap is shared.
1243 // with off-heap Addresses.
1267 // The total number of native contexts object on the heap.
1284 // Returns the maximum amount of memory reserved for the heap.
1309 // Returns the capacity of the heap in bytes w/o growing. Heap grows when
1319 // Returns the amount of memory currently committed for the heap.
1325 // Returns the amount of executable memory currently committed for the heap.
1328 // Returns the amount of phyical memory currently committed for the heap.
1331 // Returns the maximum amount of memory ever committed for the heap.
1334 // Updates the maximum committed memory for the heap. Should be called
1343 // Returns size of all objects residing in the heap.
1346 // Returns size of all global handles in the heap.
1349 // Returns size of all allocated/used global handles in the heap.
1469 // Creates a filler object and returns a heap object immediately after it.
1473 // Creates a filler object if needed for alignment and returns a heap object
1569 // Casts a heap object to a code object and checks if the inner_pointer is
1579 // Verify the heap is in its normal state before or after a GC.
1581 // Verify the read-only heap after all read-only heap objects have been
1637 using ExternalStringTableUpdaterCallback = String (*)(Heap* heap,
1645 explicit ExternalStringTable(Heap* heap) : heap_(heap) {}
1759 // Free all LABs in the heap.
1775 // Performs garbage collection in the shared heap.
1798 // Initialize a filler object to keep the ability to iterate over the heap
1900 // Performs a major collection in the whole heap.
2037 // Allocates a JS Map in the heap.
2067 // Allocates a heap object based on the map.
2114 // This can be calculated directly from a pointer to the heap; however, it is
2314 // This object controls virtual space reserved for code on the V8 heap. This
2317 // Owned by the heap when !V8_COMPRESS_POINTERS_IN_SHARED_CAGE, otherwise is
2321 // The embedder owns the C++ heap.
2368 // Flag is set when the heap has been configured. The heap can be repeatedly
2429 // Classes in "heap" can be friends.
2466 friend class heap::TestMemoryAllocatorScope;
2480 friend class heap::HeapTester;
2519 // outside heap, deserializer, and isolate bootstrap.
2532 explicit inline AlwaysAllocateScope(Heap* heap);
2536 // Like AlwaysAllocateScope if the heap argument to the constructor is
2550 explicit inline OptionalAlwaysAllocateScope(Heap* heap);
2556 explicit inline AlwaysAllocateScopeForTesting(Heap* heap);
2565 explicit inline CodeSpaceMemoryModificationScope(Heap* heap);
2576 explicit inline CodePageCollectionMemoryModificationScope(Heap* heap);
2603 explicit inline IgnoreLocalGCRequests(Heap* heap);
2611 // or care about intergenerational references. All heap object pointers have to
2612 // point into the heap to a location that has a map pointer at its first word.
2614 // objects in a heap space but above the allocation pointer.
2618 V8_INLINE explicit VerifyPointersVisitor(Heap* heap);
2653 // Space iterator for iterating over all the paged spaces of the heap: Map
2658 explicit PagedSpaceIterator(Heap* heap)
2659 : heap_(heap), counter_(FIRST_GROWABLE_PAGED_SPACE) {}
2669 explicit SpaceIterator(Heap* heap);
2680 // A HeapObjectIterator provides iteration over the entire non-read-only heap.
2687 // HeapObjectIterator can skip free list nodes (that is, de-allocated heap
2688 // objects that still remain in the heap). As implementation of free nodes
2690 // forbidden to interrupt iteration in this mode, as this will leave heap
2700 explicit HeapObjectIterator(Heap* heap,
2733 // Allows observation of heap object allocations.
2759 explicit StrongRootBlockAllocator(Heap* heap) : heap_(heap) {}
2797 EmbedderStackStateScope(Heap* heap, Origin origin,