Lines Matching full:heap
36 #include "heap-profiler.h"
68 Heap::Heap()
135 previous_survival_rate_trend_(Heap::STABLE),
136 survival_rate_trend_(Heap::STABLE),
162 intptr_t Heap::Capacity() {
174 intptr_t Heap::CommittedMemory() {
186 intptr_t Heap::CommittedMemoryExecutable() {
193 intptr_t Heap::Available() {
205 bool Heap::HasBeenSetup() {
215 int Heap::GcSafeSizeOfOldObject(HeapObject* object) {
216 ASSERT(!HEAP->InNewSpace(object)); // Code only works for old objects.
217 ASSERT(!HEAP->mark_compact_collector()->are_map_pointers_encoded());
225 int Heap::GcSafeSizeOfOldObjectWithEncodedMap(HeapObject* object) {
226 ASSERT(!HEAP->InNewSpace(object)); // Code only works for old objects.
227 ASSERT(HEAP->mark_compact_collector()->are_map_pointers_encoded());
235 Address map_address = map_word.DecodeMapAddress(HEAP->map_space());
242 GarbageCollector Heap::SelectGarbageCollector(AllocationSpace space) {
282 // TODO(1238405): Combine the infrastructure for --heap-stats and
285 void Heap::ReportStatisticsBeforeGC() {
286 // Heap::ReportHeapStatistics will also log NewSpace statistics when
314 void Heap::PrintShortHeapStatistics() {
322 Heap::new_space_.Size(),
362 // TODO(1238405): Combine the infrastructure for --heap-stats and
364 void Heap::ReportStatisticsAfterGC() {
383 void Heap::GarbageCollectionPrologue() {
406 intptr_t Heap::SizeOfObjects() {
415 void Heap::GarbageCollectionEpilogue() {
447 void Heap::CollectAllGarbage(bool force_compaction) {
457 void Heap::CollectAllAvailableGarbage() {
481 bool Heap::CollectGarbage(AllocationSpace space, GarbageCollector collector) {
525 void Heap::PerformScavenge() {
551 HEAP->symbol_table()->IterateElements(&verifier);
556 void Heap::ReserveSpace(
564 NewSpace* new_space = Heap::new_space();
565 PagedSpace* old_pointer_space = Heap::old_pointer_space();
566 PagedSpace* old_data_space = Heap::old_data_space();
567 PagedSpace* code_space = Heap::code_space();
568 PagedSpace* map_space = Heap::map_space();
569 PagedSpace* cell_space = Heap::cell_space();
570 LargeObjectSpace* lo_space = Heap::lo_space();
575 Heap::CollectGarbage(NEW_SPACE);
579 Heap::CollectGarbage(OLD_POINTER_SPACE);
583 Heap::CollectGarbage(OLD_DATA_SPACE);
587 Heap::CollectGarbage(CODE_SPACE);
591 Heap::CollectGarbage(MAP_SPACE);
595 Heap::CollectGarbage(CELL_SPACE);
607 Heap::CollectGarbage(LO_SPACE);
614 void Heap::EnsureFromSpaceIsCommitted() {
635 void Heap::ClearJSFunctionResultCaches() {
655 void Heap::ClearNormalizedMapCaches() {
684 void Heap::UpdateSurvivalRateTrend(int start_new_space_size) {
708 bool Heap::PerformGarbageCollection(GarbageCollector collector,
734 int start_new_space_size = Heap::new_space()->SizeAsInt();
810 void Heap::MarkCompact(GCTracer* tracer) {
843 void Heap::MarkCompactPrologue(bool is_compacting) {
860 Object* Heap::FindCodeObject(Address a) {
874 explicit ScavengeVisitor(Heap* heap) : heap_(heap) {}
887 Heap::ScavengeObject(reinterpret_cast<HeapObject**>(p),
891 Heap* heap_;
903 ASSERT(!HEAP->InNewSpace(HeapObject::cast(*current)));
914 HeapObjectIterator code_it(HEAP->code_space());
919 HeapObjectIterator data_it(HEAP->old_data_space());
927 void Heap::CheckNewSpaceExpansionCriteria() {
938 void Heap::Scavenge() {
1005 &Heap::IteratePointersInDirtyRegion,
1056 String* Heap::UpdateNewSpaceReferenceInExternalStringTableEntry(Heap* heap,
1062 heap->FinalizeExternalString(String::cast(*p));
1071 void Heap::UpdateNewSpaceReferencesInExternalStringTable(
1104 static Object* ProcessFunctionWeakReferences(Heap* heap,
1107 Object* head = heap->undefined_value();
1110 while (candidate != heap->undefined_value()) {
1115 if (head == heap->undefined_value()) {
1132 tail->set_next_function_link(heap->undefined_value());
1139 void Heap::ProcessWeakReferences(WeakObjectRetainer* retainer) {
1181 Heap::undefined_value(),
1192 static inline void VisitPointer(Heap* heap, Object** p) {
1194 if (!heap->InNewSpace(object)) return;
1195 Heap::ScavengeObject(reinterpret_cast<HeapObject**>(p),
1201 Address Heap::DoScavenge(ObjectVisitor* scavenge_visitor,
1311 static void RecordCopiedObject(Heap* heap, HeapObject* obj) {
1320 if (heap->new_space()->Contains(obj)) {
1321 heap->new_space()->RecordAllocation(obj);
1323 heap->new_space()->RecordPromotion(obj);
1332 INLINE(static HeapObject* MigrateObject(Heap* heap,
1337 heap->CopyBlock(target->address(), source->address(), size);
1345 RecordCopiedObject(heap, target);
1347 HEAP_PROFILE(heap, ObjectMoveEvent(source->address(), target->address()));
1349 Isolate* isolate = heap->isolate();
1373 Heap* heap = map->heap();
1374 if (heap->ShouldBePromoted(object->address(), object_size)) {
1379 maybe_result = heap->lo_space()->AllocateRawFixedArray(object_size);
1382 maybe_result = heap->old_data_space()->AllocateRaw(object_size);
1384 maybe_result = heap->old_pointer_space()->AllocateRaw(object_size);
1391 *slot = MigrateObject(heap, object , target, object_size);
1394 heap->promotion_queue()->insert(target, object_size);
1397 heap->tracer()->increment_promoted_objects_size(object_size);
1402 heap->new_space()->AllocateRaw(object_size)->ToObjectUnchecked();
1403 *slot = MigrateObject(heap, object, HeapObject::cast(result), object_size);
1455 map->heap()->empty_string()) {
1461 if (!map->heap()->InNewSpace(first)) {
1520 void Heap::SwitchScavengingVisitorsTableIfProfilingWasEnabled() {
1549 void Heap::ScavengeObjectSlow(HeapObject** p, HeapObject* object) {
1550 ASSERT(HEAP->InFromSpace(object));
1558 MaybeObject* Heap::AllocatePartialMap(InstanceType instance_type,
1580 MaybeObject* Heap::AllocateMap(InstanceType instance_type, int instance_size) {
1613 MaybeObject* Heap::AllocateCodeCache() {
1625 const Heap::StringTypeTable Heap::string_type_table[] = {
1633 const Heap::ConstantSymbolTable Heap::constant_symbol_table[] = {
1641 const Heap::StructTable Heap::struct_table[] = {
1649 bool Heap::CreateInitialMaps() {
1880 MaybeObject* Heap::AllocateHeapNumber(double value, PretenureFlag pretenure) {
1881 // Statically ensure that it is safe to allocate heap numbers in paged
1898 MaybeObject* Heap::AllocateHeapNumber(double value) {
1916 MaybeObject* Heap::AllocateJSGlobalPropertyCell(Object* value) {
1927 MaybeObject* Heap::CreateOddball(const char* to_string,
1938 bool Heap::CreateApiObjects() {
1961 void Heap::CreateJSEntryStub() {
1967 void Heap::CreateJSConstructEntryStub() {
1973 void Heap::CreateFixedStubs() {
1987 Heap::CreateJSEntryStub();
1988 Heap::CreateJSConstructEntryStub();
1992 bool Heap::CreateInitialObjects() {
2176 MaybeObject* Heap::InitializeNumberStringCache() {
2177 // Compute the size of the number string cache based on the max heap size.
2190 void Heap::FlushNumberStringCache() {
2210 Object* Heap::GetNumberStringCache(Object* number) {
2230 void Heap::SetNumberStringCache(Object* number, String* string) {
2244 MaybeObject* Heap::NumberToString(Object* number,
2274 Map* Heap::MapForExternalArrayType(ExternalArrayType array_type) {
2279 Heap::RootListIndex Heap::RootIndexForExternalArrayType(
2305 MaybeObject* Heap::NumberFromDouble(double value, PretenureFlag pretenure) {
2321 // Materialize the value in the heap.
2326 MaybeObject* Heap::AllocateProxy(Address proxy, PretenureFlag pretenure) {
2340 MaybeObject* Heap::AllocateSharedFunctionInfo(Object* name) {
2377 MaybeObject* Heap::AllocateJSMessageObject(String* type,
2389 message->set_properties(Heap::empty_fixed_array());
2390 message->set_elements(Heap::empty_fixed_array());
2411 Heap* heap,
2418 heap->symbol_table()->LookupTwoCharsSymbolIfExists(c1, c2, &symbol)) {
2425 { MaybeObject* maybe_result = heap->AllocateRawAsciiString(2);
2434 { MaybeObject* maybe_result = heap->AllocateRawTwoByteString(2);
2445 MaybeObject* Heap::AllocateConsString(String* first, String* second) {
2562 MaybeObject* Heap::AllocateSubString(String* buffer,
2604 MaybeObject* Heap::AllocateExternalStringFromAscii(
2627 MaybeObject* Heap::AllocateExternalStringFromTwoByte(
2656 MaybeObject* Heap::LookupSingleCharacterStringFromCode(uint16_t code) {
2681 MaybeObject* Heap::AllocateByteArray(int length, PretenureFlag pretenure) {
2702 MaybeObject* Heap::AllocateByteArray(int length) {
2720 void Heap::CreateFillerObjectAt(Address addr, int size) {
2734 MaybeObject* Heap::AllocateExternalArray(int length,
2756 MaybeObject* Heap::CreateCode(const CodeDesc& desc,
2761 // leaving uninitialized Code object (and breaking the heap).
2802 // that are dereferenced during the copy to point directly to the actual heap
2814 MaybeObject* Heap::CopyCode(Code* code) {
2840 MaybeObject* Heap::CopyCode(Code* code, Vector<byte> reloc_info) {
2842 // leaving uninitialized Code object (and breaking the heap).
2894 MaybeObject* Heap::Allocate(Map* map, AllocationSpace space) {
2914 MaybeObject* Heap::InitializeFunction(JSFunction* function,
2930 MaybeObject* Heap::AllocateFunctionPrototype(JSFunction* function) {
2952 MaybeObject* Heap::AllocateFunction(Map* function_map,
2966 MaybeObject* Heap::AllocateArgumentsObject(Object* callee, int length) {
2985 // This calls Copy directly rather than using Heap::AllocateRaw so we
3040 MaybeObject* Heap::AllocateInitialMap(JSFunction* fun) {
3116 void Heap::InitializeJSObjectFromMap(JSObject* obj,
3125 // fixed array (eg, Heap::empty_fixed_array()). Currently, the object
3137 filler = Heap::one_pointer_filler_map();
3139 filler = Heap::undefined_value();
3145 MaybeObject* Heap::AllocateJSObjectFromMap(Map* map, PretenureFlag pretenure) {
3184 MaybeObject* Heap::AllocateJSObject(JSFunction* constructor,
3207 MaybeObject* Heap::AllocateGlobalObject(JSFunction* constructor) {
3280 MaybeObject* Heap::CopyJSObject(JSObject* source) {
3345 MaybeObject* Heap::ReinitializeJSGlobalProxy(JSFunction* constructor,
3371 MaybeObject* Heap::AllocateStringFromAscii(Vector<const char> string,
3388 MaybeObject* Heap::AllocateStringFromUtf8Slow(Vector<const char> string,
3420 MaybeObject* Heap::AllocateStringFromTwoByte(Vector<const uc16> string,
3442 Map* Heap::SymbolMapForString(String* string) {
3475 MaybeObject* Heap::AllocateInternalSymbol(unibrow::CharacterStream* buffer,
3533 MaybeObject* Heap::AllocateRawAsciiString(int length, PretenureFlag pretenure) {
3569 MaybeObject* Heap::AllocateRawTwoByteString(int length,
3604 MaybeObject* Heap::AllocateEmptyFixedArray() {
3618 MaybeObject* Heap::AllocateRawFixedArray(int length) {
3633 MaybeObject* Heap::CopyFixedArrayWithMap(FixedArray* src, Map* map) {
3659 MaybeObject* Heap::AllocateFixedArray(int length) {
3677 MaybeObject* Heap::AllocateRawFixedArray(int length, PretenureFlag pretenure) {
3702 Heap* heap,
3707 ASSERT(heap->empty_fixed_array()->IsFixedArray());
3708 if (length == 0) return heap->empty_fixed_array();
3710 ASSERT(!heap->InNewSpace(filler));
3712 { MaybeObject* maybe_result = heap->AllocateRawFixedArray(length, pretenure);
3716 HeapObject::cast(result)->set_map(heap->fixed_array_map());
3724 MaybeObject* Heap::AllocateFixedArray(int length, PretenureFlag pretenure) {
3732 MaybeObject* Heap::AllocateFixedArrayWithHoles(int length,
3741 MaybeObject* Heap::AllocateUninitializedFixedArray(int length) {
3755 MaybeObject* Heap::AllocateHashTable(int length, PretenureFlag pretenure) {
3766 MaybeObject* Heap::AllocateGlobalContext() {
3780 MaybeObject* Heap::AllocateFunctionContext(int length, JSFunction* function) {
3800 MaybeObject* Heap::AllocateWithContext(Context* previous,
3822 MaybeObject* Heap::AllocateStruct(InstanceType type) {
3845 bool Heap::IdleNotification() {
3930 void Heap::Print() {
3939 void Heap::ReportCodeStatistics(const char* title) {
3953 void Heap::ReportHeapStatistics(const char* title) {
3968 PrintF("Heap statistics : ");
3989 bool Heap::Contains(HeapObject* value) {
3994 bool Heap::Contains(Address addr) {
4007 bool Heap::InSpace(HeapObject* value, AllocationSpace space) {
4012 bool Heap::InSpace(Address addr, AllocationSpace space) {
4052 HEAP->IterateDirtyRegions(Page::kAllRegionsDirtyMarks,
4070 // When we are not in GC the Heap::InNewSpace() predicate
4073 HEAP->InNewSpace(*slot);
4081 void Heap::Verify() {
4112 MaybeObject* Heap::LookupSymbol(Vector<const char> string) {
4127 MaybeObject* Heap::LookupAsciiSymbol(Vector<const char> string) {
4142 MaybeObject* Heap::LookupTwoByteSymbol(Vector<const uc16> string) {
4157 MaybeObject* Heap::LookupSymbol(String* string) {
4173 bool Heap::LookupSymbolIfExists(String* string, String** symbol) {
4183 void Heap::ZapFromSpace() {
4194 bool Heap::IteratePointersInDirtyRegion(Heap* heap,
4203 if (heap->InNewSpace(*slot)) {
4206 if (heap->InNewSpace(*slot)) {
4240 Heap* heap = HEAP;
4242 ASSERT(!heap->InNewSpace(Memory::Object_at(map_address)));
4248 if (Heap::IteratePointersInDirtyRegion(heap,
4262 bool Heap::IteratePointersInDirtyMapsRegion(
4263 Heap* heap,
4283 IteratePointersInDirtyRegion(heap,
4306 IteratePointersInDirtyRegion(heap,
4317 void Heap::IterateAndMarkPointersToFromSpace(Address start,
4342 uint32_t Heap::IterateDirtyRegions(
4411 void Heap::IterateDirtyRegions(
4455 void Heap::IterateRoots(ObjectVisitor* v, VisitMode mode) {
4461 void Heap::IterateWeakRoots(ObjectVisitor* v, VisitMode mode) {
4472 void Heap::IterateStrongRoots(ObjectVisitor* v, VisitMode mode) {
4498 // heap. Note that it is not necessary to iterate over code objects
4533 // TODO(1236194): Since the heap size is configurable on the command line
4534 // and through the API, we should gracefully handle the case that the heap
4536 bool Heap::ConfigureHeap(int max_semispace_size,
4584 bool Heap::ConfigureHeapDefault() {
4591 void Heap::RecordStats(HeapStats* stats, bool take_snapshot) {
4628 intptr_t Heap::PromotedSpaceSize() {
4638 int Heap::PromotedExternalMemorySize() {
4653 explicit HeapDebugUtils(Heap* heap)
4658 heap_(heap) {
4804 Heap* heap_;
4806 friend class Heap;
4811 bool Heap::Setup(bool create_heap_objects) {
4816 // Initialize heap spaces and initial maps and objects. Whenever something
4818 // call Heap::TearDown() to release allocated memory.
4820 // If the heap is not yet configured (eg, through the API), configure it.
4924 LOG(isolate_, IntPtrTEvent("heap-capacity", Capacity()));
4925 LOG(isolate_, IntPtrTEvent("heap-available", Available()));
4936 void Heap::SetStackLimits() {
4953 void Heap::TearDown() {
5017 void Heap::Shrink() {
5027 void Heap::Protect() {
5036 void Heap::Unprotect() {
5047 void Heap::AddGCPrologueCallback(GCPrologueCallback callback, GCType gc_type) {
5055 void Heap::RemoveGCPrologueCallback(GCPrologueCallback callback) {
5067 void Heap::AddGCEpilogueCallback(GCEpilogueCallback callback, GCType gc_type) {
5075 void Heap::RemoveGCEpilogueCallback(GCEpilogueCallback callback) {
5099 void Heap::PrintHandles() {
5111 return HEAP->new_space();
5113 return HEAP->old_pointer_space();
5115 return HEAP->old_data_space();
5117 return HEAP->code_space();
5119 return HEAP->map_space();
5121 return HEAP->cell_space();
5123 return HEAP->lo_space();
5133 return HEAP->old_pointer_space();
5135 return HEAP->old_data_space();
5137 return HEAP->code_space();
5139 return HEAP->map_space();
5141 return HEAP->cell_space();
5152 return HEAP->old_pointer_space();
5154 return HEAP->old_data_space();
5156 return HEAP->code_space();
5211 iterator_ = new SemiSpaceIterator(HEAP->new_space(), size_func_);
5214 iterator_ = new HeapObjectIterator(HEAP->old_pointer_space(), size_func_);
5217 iterator_ = new HeapObjectIterator(HEAP->old_data_space(), size_func_);
5220 iterator_ = new HeapObjectIterator(HEAP->code_space(), size_func_);
5223 iterator_ = new HeapObjectIterator(HEAP->map_space(), size_func_);
5226 iterator_ = new HeapObjectIterator(HEAP->cell_space(), size_func_);
5229 iterator_ = new LargeObjectIterator(HEAP->lo_space(), size_func_);
5263 Heap* heap = HEAP;
5264 heap->old_pointer_space()->MarkFreeListNodes();
5265 heap->old_data_space()->MarkFreeListNodes();
5266 MarkCodeSpaceFreeListNodes(heap);
5267 heap->map_space()->MarkFreeListNodes();
5268 heap->cell_space()->MarkFreeListNodes();
5271 void MarkCodeSpaceFreeListNodes(Heap* heap) {
5273 HeapObjectIterator iter(heap->code_space());
5335 HEAP->IterateRoots(&visitor, VISIT_ALL);
5384 // objects. Otherwise, heap will be left in an inconsistent state.
5607 // and finds a path to a specific heap object and prints it.
5608 void Heap::TracePathToObject(Object* target) {
5617 void Heap::TracePathToGlobal() {
5638 GCTracer::GCTracer(Heap* heap)
5648 heap_(heap) {
5780 if (HEAP->LookupSymbolIfExists(name, &symbol)) {
5801 void Heap::GarbageCollectionGreedyCheck() {
