| /external/v8/src/ |
| objects-body-descriptors.h | 43 static inline void IteratePointers(Heap* heap, HeapObject* obj,
51 static inline void IteratePointer(Heap* heap, HeapObject* obj, int offset);
64 static inline void IterateBodyImpl(Heap* heap, HeapObject* obj,
96 Heap* heap = obj->GetHeap(); local
97 IterateBodyImpl<StaticVisitor>(heap, obj, start_offset, end_offset);
128 Heap* heap = obj->GetHeap() local
[all...] |
| identity-map.h | 15 class Heap;
33 explicit IdentityMapBase(Heap* heap)
34 : heap_(heap),
70 Heap* heap_;
84 // supplied {heap}.
87 // * The value type {V} must not be a heap type.
91 explicit IdentityMap(Heap* heap,
93 : IdentityMapBase(heap), allocator_(allocator) {
[all...] |
| /external/v8/src/heap/ |
| heap.cc | 5 #include "src/heap/heap.h"
23 #include "src/heap/array-buffer-tracker-inl.h"
24 #include "src/heap/code-stats.h"
25 #include "src/heap/embedder-tracing.h"
26 #include "src/heap/gc-idle-time-handler.h"
27 #include "src/heap/gc-tracer.h"
28 #include "src/heap/incremental-marking.h"
29 #include "src/heap/mark-compact-inl.h"
30 #include "src/heap/mark-compact.h
[all...] |
| objects-visiting.h | 9 #include "src/heap/embedder-tracing.h"
10 #include "src/heap/heap.h"
11 #include "src/heap/spaces.h"
136 DCHECK(Heap::kMinObjectSizeInWords * kPointerSize <= object_size);
144 base + (object_size >> kPointerSizeLog2) - Heap::kMinObjectSizeInWords,
187 STATIC_ASSERT((generic - base + Heap::kMinObjectSizeInWords) == 10);
262 INLINE(static void VisitPointers(Heap* heap, HeapObject* object,
265 StaticVisitor::VisitPointer(heap, object, p)
[all...] |
| object-stats.h | 11 #include "src/heap/heap.h"
12 #include "src/heap/objects-visiting.h"
20 explicit ObjectStats(Heap* heap) : heap_(heap) { ClearObjectStats(); }
94 Heap* heap() { return heap_; } function in class:v8::internal::ObjectStats
118 Heap* heap_;
135 ObjectStatsCollector(Heap* heap, ObjectStats* stats
[all...] |
| page-parallel-job.h | 16 class Heap;
23 // - static bool ProcessPageInParallel(Heap* heap,
29 // - static void FinalizePageSequentially(Heap* heap,
42 PageParallelJob(Heap* heap, CancelableTaskManager* cancelable_task_manager,
44 : heap_(heap),
138 Task(Heap* heap, Item* items, int num_items, int start_index
[all...] |
| objects-visiting-inl.h | 8 #include "src/heap/array-buffer-tracker.h"
9 #include "src/heap/mark-compact.h"
10 #include "src/heap/objects-visiting.h"
217 Heap* heap, HeapObject* object, Address entry_address) {
219 heap->mark_compact_collector()->RecordCodeEntrySlot(object, entry_address,
221 StaticVisitor::MarkObject(heap, code);
227 Heap* heap, RelocInfo* rinfo) {
231 heap->mark_compact_collector()->RecordRelocSlot(host, rinfo, object)
306 Heap* heap = map->GetHeap(); local
329 Heap* heap = map->GetHeap(); local
358 Heap* heap = array->GetHeap(); local
371 Heap* heap = map->GetHeap(); local
384 Heap* heap = map->GetHeap(); local
414 Heap* heap = map->GetHeap(); local
426 Heap* heap = map->GetHeap(); local
453 Heap* heap = map->GetHeap(); local
[all...] |
| embedder-tracing.h | 15 class Heap;
|
| array-buffer-tracker-inl.h | 6 #include "src/heap/array-buffer-tracker.h"
7 #include "src/heap/heap.h"
13 void ArrayBufferTracker::RegisterNew(Heap* heap, JSArrayBuffer* buffer) {
31 reinterpret_cast<v8::Isolate*>(heap->isolate())
35 void ArrayBufferTracker::Unregister(Heap* heap, JSArrayBuffer* buffer) {
47 heap->update_external_memory(-static_cast<intptr_t>(length));
|
| incremental-marking.h | 10 #include "src/heap/heap.h"
11 #include "src/heap/incremental-marking-job.h"
12 #include "src/heap/mark-compact.h"
13 #include "src/heap/spaces.h"
35 explicit IncrementalMarking(Heap* heap);
182 static void MarkGrey(Heap* heap, HeapObject* object);
186 static void TransferMark(Heap* heap, HeapObject* from, HeapObject* to)
212 Heap* heap() const { return heap_; } function in class:v8::internal::IncrementalMarking
[all...] |
| mark-compact.h | 13 #include "src/heap/marking.h"
14 #include "src/heap/spaces.h"
15 #include "src/heap/store-buffer.h"
22 // Callback function, returns whether an object is alive. The heap size
27 // Callback function to mark an object in a given heap.
28 typedef void (*MarkObjectFunction)(Heap* heap, HeapObject* object);
127 explicit MarkingDeque(Heap* heap)
137 heap_(heap) {}
394 inline Heap* heap() { return chunk_->heap(); } function in class:v8::internal::BASE_EMBEDDED
521 inline Heap* heap() const { return heap_; } function in class:v8::internal::MarkCompactCollector
[all...] |
| spaces-inl.h | 8 #include "src/heap/incremental-marking.h"
9 #include "src/heap/spaces.h"
12 #include "src/profiler/heap-profiler.h"
85 DCHECK_EQ(space_, space_->heap()->code_space());
172 Page* Page::Initialize(Heap* heap, MemoryChunk* chunk, Executability executable,
181 heap->incremental_marking()->SetNewSpacePageFlags(page);
190 Page* Page::Initialize(Heap* heap, MemoryChunk* chunk, Executability executable,
197 heap->incremental_marking()->SetOldSpacePageFlags(chunk)
[all...] |
| store-buffer.h | 13 #include "src/heap/remembered-set.h"
14 #include "src/heap/slot-set.h"
36 explicit StoreBuffer(Heap* heap);
155 Heap* heap() { return heap_; } function in class:v8::internal::StoreBuffer
185 Heap* heap_;
|
| /art/runtime/gc/ |
| heap.cc | 17 #include "heap.h"
68 #include "heap-inl.h"
69 #include "heap-visit-objects-inl.h"
130 // For deterministic compilation, we need the heap to be at a well-known address.
147 reinterpret_cast<uint8_t*>(300 * MB - Heap::kDefaultNonMovingSpaceCapacity);
162 Heap::Heap(size_t initial_size,
239 * causes a lot of GC since we do a GC for alloc whenever the stack is full. When heap
285 if (VLOG_IS_ON(heap) || VLOG_IS_ON(startup)) {
286 LOG(INFO) << "Heap() entering"
3569 gc::Heap* heap = Runtime::Current()->GetHeap(); variable
3627 gc::Heap* heap = Runtime::Current()->GetHeap(); variable
3669 gc::Heap* heap = Runtime::Current()->GetHeap(); variable
[all...] |
| heap-inl.h | 20 #include "heap.h"
44 inline mirror::Object* Heap::AllocObjectWithAllocator(Thread* self,
222 inline void Heap::PushOnAllocationStack(Thread* self, ObjPtr<mirror::Object>* obj) {
233 inline mirror::Object* Heap::AllocLargeObject(Thread* self,
246 inline mirror::Object* Heap::TryToAllocate(Thread* self,
383 inline bool Heap::ShouldAllocLargeObject(ObjPtr<mirror::Class> c, size_t byte_count) const {
391 inline bool Heap::IsOutOfMemoryOnAllocation(AllocatorType allocator_type,
404 VLOG(heap) << "Growing heap from " << PrettySize(max_allowed_footprint_) << " to "
412 inline void Heap::CheckConcurrentGC(Thread* self
[all...] |
| /external/v8/src/profiler/ |
| sampling-heap-profiler.h | 13 #include "src/heap/heap.h"
44 SamplingHeapProfiler(Heap* heap, StringsStorage* names, uint64_t rate,
123 Heap* heap() const { return heap_; } function in class:v8::internal::SamplingHeapProfiler
144 Heap* const heap_;
161 SamplingAllocationObserver(Heap* heap, intptr_t step_size, uint64_t rate,
166 heap_(heap),
[all...] |
| strings-storage.h | 17 // Provides a storage of strings allocated in C++ heap, to hold them
18 // forever, even if they disappear from JS heap or external storage.
21 explicit StringsStorage(Heap* heap);
|
| heap-profiler.h | 25 explicit HeapProfiler(Heap* heap);
80 Isolate* isolate() const { return heap()->isolate(); }
83 Heap* heap() const;
|
| /art/runtime/gc/collector/ |
| garbage_collector.h | 44 class Heap;
62 GarbageCollector(Heap* heap, const std::string& name);
71 Heap* GetHeap() const {
115 // Returns true if the given heap reference is null or is already marked. If it's already marked,
145 Heap* const heap_;
|
| partial_mark_sweep.cc | 19 #include "gc/heap.h"
28 PartialMarkSweep::PartialMarkSweep(Heap* heap, bool is_concurrent, const std::string& name_prefix)
29 : MarkSweep(heap, is_concurrent, name_prefix.empty() ? "partial " : name_prefix) {
|
| sticky_mark_sweep.h | 33 StickyMarkSweep(Heap* heap, bool is_concurrent, const std::string& name_prefix = "");
|
| /external/v8/src/snapshot/ |
| natives.h | 53 static FixedArray* GetSourceCache(Heap* heap);
|
| startup-serializer.cc | 44 obj = isolate()->heap()->undefined_value();
97 Object* undefined = isolate()->heap()->undefined_value();
99 isolate()->heap()->IterateWeakRoots(this, VISIT_ALL);
132 isolate->heap()->IterateStrongRoots(this, VISIT_ONLY_STRONG_ROOT_LIST);
139 isolate->heap()->ClearStackLimits();
140 isolate->heap()->IterateSmiRoots(this);
141 isolate->heap()->SetStackLimits();
143 isolate->heap()->IterateStrongRoots(this,
148 if (start == isolate()->heap()->roots_array_start()) {
179 if (root_index == Heap::kStackLimitRootIndex |
[all...] |
| deserializer.h | 8 #include "src/heap/heap.h"
26 class Heap;
47 // Deserialize the snapshot into an empty heap.
100 // Fills in some heap data in an area from start to end (non-inclusive). The
104 // the heap. Return false if the object content has been deferred.
133 Heap::Reservation reservations_[kNumberOfSpaces];
|
| /prebuilts/go/darwin-x86/test/ |
| notinheap2.go | 25 // Heap allocation is not okay.
31 y = new(nih) // ERROR "heap allocation disallowed"
32 z = make([]nih, 1) // ERROR "heap allocation disallowed"
33 z = append(z, x) // ERROR "heap allocation disallowed"
|
