Lines Matching refs:heap
5 #include "src/heap/heap.h"
36 #include "src/heap/array-buffer-sweeper.h"
37 #include "src/heap/base/stack.h"
38 #include "src/heap/basic-memory-chunk.h"
39 #include "src/heap/code-object-registry.h"
40 #include "src/heap/code-range.h"
41 #include "src/heap/code-stats.h"
42 #include "src/heap/collection-barrier.h"
43 #include "src/heap/combined-heap.h"
44 #include "src/heap/concurrent-allocator.h"
45 #include "src/heap/concurrent-marking.h"
46 #include "src/heap/cppgc-js/cpp-heap.h"
47 #include "src/heap/embedder-tracing.h"
48 #include "src/heap/finalization-registry-cleanup-task.h"
49 #include "src/heap/gc-idle-time-handler.h"
50 #include "src/heap/gc-tracer-inl.h"
51 #include "src/heap/gc-tracer.h"
52 #include "src/heap/heap-controller.h"
53 #include "src/heap/heap-layout-tracer.h"
54 #include "src/heap/heap-write-barrier-inl.h"
55 #include "src/heap/incremental-marking-inl.h"
56 #include "src/heap/incremental-marking.h"
57 #include "src/heap/large-spaces.h"
58 #include "src/heap/local-heap.h"
59 #include "src/heap/mark-compact-inl.h"
60 #include "src/heap/mark-compact.h"
61 #include "src/heap/marking-barrier-inl.h"
62 #include "src/heap/marking-barrier.h"
63 #include "src/heap/memory-chunk-inl.h"
64 #include "src/heap/memory-chunk-layout.h"
65 #include "src/heap/memory-measurement.h"
66 #include "src/heap/memory-reducer.h"
67 #include "src/heap/object-stats.h"
68 #include "src/heap/objects-visiting-inl.h"
69 #include "src/heap/objects-visiting.h"
70 #include "src/heap/paged-spaces-inl.h"
71 #include "src/heap/parked-scope.h"
72 #include "src/heap/read-only-heap.h"
73 #include "src/heap/remembered-set.h"
74 #include "src/heap/safepoint.h"
75 #include "src/heap/scavenge-job.h"
76 #include "src/heap/scavenger-inl.h"
77 #include "src/heap/stress-marking-observer.h"
78 #include "src/heap/stress-scavenge-observer.h"
79 #include "src/heap/sweeper.h"
107 #include "src/heap/conservative-stack-visitor.h"
125 // in heap-write-barrier-inl.h.
152 void Heap_GenerationalEphemeronKeyBarrierSlow(Heap* heap,
155 heap->RecordEphemeronKeyWrite(table, slot);
194 ScavengeTaskObserver(Heap* heap, intptr_t step_size)
195 : AllocationObserver(step_size), heap_(heap) {}
272 // Initialize values for the case when the given heap size is too small.
276 // heap limit considering the correspondingly sized young generation.
283 // This size configuration fits into the given heap limit.
305 // Isolate and the young generation are also allocated on the heap.
316 // Finch experiment: Increase the heap size from 2GB to 4GB for 64-bit
428 // the total allocated memory size over the maximum heap size.
436 // When the heap is tearing down, then GC requests from background threads
437 // are not served and the threads are allowed to expand the heap to avoid OOM.
452 // We will always have an old space when the heap is set up.
737 explicit AllocationTrackerForDebugging(Heap* heap) : heap_(heap) {
1366 // performance issue, use a cache data structure in heap instead.
1507 explicit GCCallbacksScope(Heap* heap) : heap_(heap) {
1735 Heap::DevToolsTraceEventScope::DevToolsTraceEventScope(Heap* heap,
1738 : heap_(heap), event_name_(event_name) {
1765 // During isolate initialization heap always grows. GC is only requested
1970 FatalProcessOutOfMemory("Reached heap limit");
2249 // If heap verification is enabled, we want to ensure that sweeping is
2396 isolate()->shared_isolate()->heap()->PerformSharedGarbageCollection(
2416 client->heap()->FreeSharedLinearAllocationAreas();
2418 // As long as we need to iterate the client heap to find references into the
2419 // shared heap, all client heaps need to be iterable.
2420 client->heap()->MakeHeapIterable();
2423 client->heap()->concurrent_marking()->Pause();
2432 client->heap()->incremental_marking()->IsMarking()) {
2433 client->heap()->concurrent_marking()->RescheduleJobIfNeeded();
2592 // Disable soft allocation limits in the shared heap, if one exists, as
2593 // promotions into the shared heap should always succeed.
2595 isolate()->shared_isolate() ? isolate()->shared_isolate()->heap()
2639 // Disable soft allocation limits in the shared heap, if one exists, as
2640 // promotions into the shared heap should always succeed.
2642 isolate()->shared_isolate() ? isolate()->shared_isolate()->heap()
2779 // Disable soft allocation limits in the shared heap, if one exists, as
2780 // promotions into the shared heap should always succeed.
2782 isolate()->shared_isolate() ? isolate()->shared_isolate()->heap()
2886 String Heap::UpdateYoungReferenceInExternalStringTableEntry(Heap* heap,
2888 PtrComprCageBase cage_base(heap->isolate());
2903 heap->FinalizeExternalString(string);
3310 HeapObject CreateFillerObjectAtImpl(Heap* heap, Address addr, int size,
3314 ReadOnlyRoots roots(heap);
3336 // At this point, we may be deserializing the heap from a snapshot, and
3339 !heap->deserialization_complete()) ||
3340 filler.map(heap->isolate()).IsMap());
3352 space->heap()->VerifySlotRangeHasNoRecordedSlots(start, end);
3401 // Sampling heap profiler may have a reference to the object.
3547 // debug mode which iterates through the heap), but to play safer
3565 // Notify the heap profiler of change in object layout.
3652 // debug mode which iterates through the heap), but to play safer
3681 // Notify the heap object allocation tracker of change in object layout. The
3820 // The callback increased the heap limit.
3824 FatalProcessOutOfMemory("Ineffective mark-compacts near heap limit");
4205 explicit MemoryPressureInterruptTask(Heap* heap)
4206 : CancelableTask(heap->isolate()), heap_(heap) {}
4444 return "heap profiler";
4452 return "make heap iterable";
4624 // The heap verifier can't deal with partially deserialized objects, so
4877 // - If the string table is shared and this is not the shared heap,
4878 // since all internalized strings are in the shared heap.
4907 explicit ClearStaleLeftTrimmedHandlesVisitor(Heap* heap)
4908 : heap_(heap)
4911 cage_base_(heap->isolate())
5015 // above is that non-transient heap state is always visited, transient heap
5092 // Iterate over the startup and shared heap object caches unless
5099 // shared heap object cache and should iterate it.
5102 // own its shared heap object cache, and should not iterate it.
5121 client->heap()->IterateRoots(v, options);
5432 // Overshoot margin is 50% of allocation limit or half-way to the max heap
5622 // configured heap any time soon. Start a memory reducer in this case
5689 // Initialize heap spaces and initial maps and objects.
5691 // If the heap is not yet configured (e.g. through the API), configure it.
5797 explicit StressConcurrentAllocationObserver(Heap* heap)
5798 : AllocationObserver(1024), heap_(heap) {}
5857 LOG(isolate_, IntPtrTEvent("heap-capacity", Capacity()));
5858 LOG(isolate_, IntPtrTEvent("heap-available", Available()));
5889 Heap* shared_heap = isolate()->shared_isolate()->heap();
6043 // The embedder is not aware of whether numbers are materialized as heap
6059 // the heap during teardown.
6080 // a good time to run heap verification (if requested), before starting to
6252 Handle<WeakArrayList> CompactWeakArrayList(Heap* heap,
6264 heap->isolate(),
6265 handle(ReadOnlyRoots(heap).empty_weak_array_list(), heap->isolate()),
6268 // cleared weak heap objects. Count the number of live references again and
6471 SpaceIterator::SpaceIterator(Heap* heap)
6472 : heap_(heap), current_space_(FIRST_MUTABLE_SPACE) {}
6502 explicit UnreachableObjectsFilter(Heap* heap) : heap_(heap) {
6629 Heap* heap, HeapObjectIterator::HeapObjectsFiltering filtering)
6630 : heap_(heap),
6631 safepoint_scope_(std::make_unique<SafepointScope>(heap)),
6655 // objects. Otherwise, heap will be left in an inconsistent state.
7309 isolate->heap()->RecordEphemeronKeyWrite(table, key_slot_address);
7446 // find a heap. The exception is when the ReadOnlySpace is writeable, during
7448 Heap* heap = Heap::FromWritableHeapObject(object);
7449 CHECK_EQ(slim_chunk->IsMarking(), heap->incremental_marking()->IsMarking());
7477 // heap as a strong root array, saves that entry in StrongRootsEntry*, and
7511 Heap* heap, Origin origin,
7513 : local_tracer_(heap->local_embedder_heap_tracer()),
7515 if (origin == kImplicitThroughTask && heap->overriden_stack_state()) {
7516 stack_state = *heap->overriden_stack_state();