diff --git a/runtime/vm/compiler/relocation.cc b/runtime/vm/compiler/relocation.cc index 83ff87cc4e8..467aa782efe 100644 --- a/runtime/vm/compiler/relocation.cc +++ b/runtime/vm/compiler/relocation.cc @@ -106,7 +106,7 @@ void CodeRelocator::FindInstructionAndCallLimits() { for (intptr_t i = 0; i < code_objects_->length(); ++i) { current_caller = (*code_objects_)[i]; - const intptr_t size = current_caller.instructions()->Size(); + const intptr_t size = current_caller.instructions()->HeapSize(); if (size > max_instructions_size_) { max_instructions_size_ = size; } @@ -181,7 +181,7 @@ bool CodeRelocator::AddInstructionsToText(RawCode* code) { } text_offsets_.Insert({instructions, next_text_offset_}); commands_->Add(ImageWriterCommand(next_text_offset_, code)); - next_text_offset_ += instructions->Size(); + next_text_offset_ += instructions->HeapSize(); return true; } diff --git a/runtime/vm/heap/become.cc b/runtime/vm/heap/become.cc index 74a72dd387b..1b1823af125 100644 --- a/runtime/vm/heap/become.cc +++ b/runtime/vm/heap/become.cc @@ -60,7 +60,7 @@ static RawObject* GetForwardedObject(RawObject* object) { } static void ForwardObjectTo(RawObject* before_obj, RawObject* after_obj) { - const intptr_t size_before = before_obj->Size(); + const intptr_t size_before = before_obj->HeapSize(); uword corpse_addr = reinterpret_cast(before_obj) - kHeapObjectTag; ForwardingCorpse* forwarder = @@ -70,7 +70,7 @@ static void ForwardObjectTo(RawObject* before_obj, RawObject* after_obj) { FATAL("become: ForwardObjectTo failure."); } // Still need to be able to iterate over the forwarding corpse. - const intptr_t size_after = before_obj->Size(); + const intptr_t size_after = before_obj->HeapSize(); if (size_before != size_after) { FATAL("become: Before and after sizes do not match."); } diff --git a/runtime/vm/heap/become.h b/runtime/vm/heap/become.h index 20804ea21d1..1b277985382 100644 --- a/runtime/vm/heap/become.h +++ b/runtime/vm/heap/become.h @@ -25,7 +25,7 @@ class ForwardingCorpse { RawObject* target() const { return target_; } void set_target(RawObject* target) { target_ = target; } - intptr_t Size() { + intptr_t HeapSize() { intptr_t size = RawObject::SizeTag::decode(tags_); if (size != 0) return size; return *SizeAddress(); diff --git a/runtime/vm/heap/compactor.cc b/runtime/vm/heap/compactor.cc index 6855871368c..e3073a01b3c 100644 --- a/runtime/vm/heap/compactor.cc +++ b/runtime/vm/heap/compactor.cc @@ -425,7 +425,7 @@ uword CompactorTask::PlanBlock(uword first_object, uword current = first_object; while (current < block_end) { RawObject* obj = RawObject::FromAddr(current); - intptr_t size = obj->Size(); + intptr_t size = obj->HeapSize(); if (obj->IsMarked()) { forwarding_block->RecordLive(current, size); ASSERT(static_cast(forwarding_block->Lookup(current)) == @@ -455,7 +455,7 @@ uword CompactorTask::SlideBlock(uword first_object, uword old_addr = first_object; while (old_addr < block_end) { RawObject* old_obj = RawObject::FromAddr(old_addr); - intptr_t size = old_obj->Size(); + intptr_t size = old_obj->HeapSize(); if (old_obj->IsMarked()) { uword new_addr = forwarding_block->Lookup(old_addr); if (new_addr != free_current_) { diff --git a/runtime/vm/heap/freelist.cc b/runtime/vm/heap/freelist.cc index 0da39c26b01..cacb13e517f 100644 --- a/runtime/vm/heap/freelist.cc +++ b/runtime/vm/heap/freelist.cc @@ -97,7 +97,7 @@ uword FreeList::TryAllocateLocked(intptr_t size, bool is_protected) { // the call to SplitElementAfterAndEnqueue. // If the remainder size is zero, only the element itself needs to // be made writable. - intptr_t remainder_size = element->Size() - size; + intptr_t remainder_size = element->HeapSize() - size; intptr_t region_size = size + FreeListElement::HeaderSizeFor(remainder_size); VirtualMemory::Protect(reinterpret_cast(element), region_size, @@ -121,10 +121,10 @@ uword FreeList::TryAllocateLocked(intptr_t size, bool is_protected) { // reset the search budget. intptr_t tries_left = freelist_search_budget_ + (size >> kWordSizeLog2); while (current != NULL) { - if (current->Size() >= size) { + if (current->HeapSize() >= size) { // Found an element large enough to hold the requested size. Dequeue, // split and enqueue the remainder. - intptr_t remainder_size = current->Size() - size; + intptr_t remainder_size = current->HeapSize() - size; intptr_t region_size = size + FreeListElement::HeaderSizeFor(remainder_size); if (is_protected) { @@ -306,10 +306,10 @@ void FreeList::PrintLarge() const { MallocDirectChainedHashMap > map; FreeListElement* node; for (node = free_lists_[kNumLists]; node != NULL; node = node->next()) { - IntptrPair* pair = map.Lookup(node->Size()); + IntptrPair* pair = map.Lookup(node->HeapSize()); if (pair == NULL) { large_sizes += 1; - map.Insert(IntptrPair(node->Size(), 1)); + map.Insert(IntptrPair(node->HeapSize(), 1)); } else { pair->set_second(pair->second() + 1); } @@ -345,7 +345,7 @@ void FreeList::SplitElementAfterAndEnqueue(FreeListElement* element, // Precondition required by AsElement and EnqueueElement: either // element->Size() == size, or else the (page containing the) header of // the remainder element starting at element + size is writable. - intptr_t remainder_size = element->Size() - size; + intptr_t remainder_size = element->HeapSize() - size; if (remainder_size == 0) return; uword remainder_address = reinterpret_cast(element) + size; @@ -379,7 +379,7 @@ FreeListElement* FreeList::TryAllocateLargeLocked(intptr_t minimum_size) { freelist_search_budget_ + (minimum_size >> kWordSizeLog2); while (current != NULL) { FreeListElement* next = current->next(); - if (current->Size() >= minimum_size) { + if (current->HeapSize() >= minimum_size) { if (previous == NULL) { free_lists_[kNumLists] = next; } else { diff --git a/runtime/vm/heap/freelist.h b/runtime/vm/heap/freelist.h index 26f2c9baa50..552c7a2ec1c 100644 --- a/runtime/vm/heap/freelist.h +++ b/runtime/vm/heap/freelist.h @@ -27,7 +27,7 @@ class FreeListElement { void set_next(FreeListElement* next) { next_ = next; } - intptr_t Size() { + intptr_t HeapSize() { intptr_t size = RawObject::SizeTag::decode(tags_); if (size != 0) return size; return *SizeAddress(); diff --git a/runtime/vm/heap/heap.cc b/runtime/vm/heap/heap.cc index 545efc7e6ca..b6b19609dbf 100644 --- a/runtime/vm/heap/heap.cc +++ b/runtime/vm/heap/heap.cc @@ -71,7 +71,7 @@ void Heap::MakeTLABIterable(Thread* thread) { if (size >= kObjectAlignment) { // ForwardingCorpse(forwarding to default null) will work as filler. ForwardingCorpse::AsForwarder(start, size); - ASSERT(RawObject::FromAddr(start)->Size() == size); + ASSERT(RawObject::FromAddr(start)->HeapSize() == size); } } diff --git a/runtime/vm/heap/marker.cc b/runtime/vm/heap/marker.cc index def2566a845..5dc41bbe5b0 100644 --- a/runtime/vm/heap/marker.cc +++ b/runtime/vm/heap/marker.cc @@ -310,7 +310,7 @@ class MarkingVisitorBase : public ObjectPointerVisitor { !raw_key->IsMarked()) { // Key was white. Enqueue the weak property. EnqueueWeakProperty(raw_weak); - return raw_weak->Size(); + return raw_weak->HeapSize(); } // Key is gray or black. Make the weak property black. return raw_weak->VisitPointersNonvirtual(this); @@ -322,7 +322,7 @@ class MarkingVisitorBase : public ObjectPointerVisitor { ASSERT(raw_obj->IsInstructions()); RawInstructions* instr = static_cast(raw_obj); if (TryAcquireMarkBit(instr)) { - intptr_t size = instr->Size(); + intptr_t size = instr->HeapSize(); marked_bytes_ += size; NOT_IN_PRODUCT(UpdateLiveOld(kInstructionsCid, size)); } diff --git a/runtime/vm/heap/pages.cc b/runtime/vm/heap/pages.cc index 1e2dd44d15f..4ba70ca3e52 100644 --- a/runtime/vm/heap/pages.cc +++ b/runtime/vm/heap/pages.cc @@ -113,7 +113,7 @@ void HeapPage::VisitObjects(ObjectVisitor* visitor) const { while (obj_addr < end_addr) { RawObject* raw_obj = RawObject::FromAddr(obj_addr); visitor->VisitObject(raw_obj); - obj_addr += raw_obj->Size(); + obj_addr += raw_obj->HeapSize(); } ASSERT(obj_addr == end_addr); } @@ -197,7 +197,7 @@ RawObject* HeapPage::FindObject(FindObjectVisitor* visitor) const { if (visitor->VisitRange(obj_addr, end_addr)) { while (obj_addr < end_addr) { RawObject* raw_obj = RawObject::FromAddr(obj_addr); - uword next_obj_addr = obj_addr + raw_obj->Size(); + uword next_obj_addr = obj_addr + raw_obj->HeapSize(); if (visitor->VisitRange(obj_addr, next_obj_addr) && raw_obj->FindObject(visitor)) { return raw_obj; // Found object, return it. @@ -860,7 +860,7 @@ class HeapMapAsJSONVisitor : public ObjectVisitor { public: explicit HeapMapAsJSONVisitor(JSONArray* array) : array_(array) {} virtual void VisitObject(RawObject* obj) { - array_->AddValue(obj->Size() / kObjectAlignment); + array_->AddValue(obj->HeapSize() / kObjectAlignment); array_->AddValue(obj->GetClassId()); } @@ -1297,7 +1297,7 @@ uword PageSpace::TryAllocateDataBumpInternal(intptr_t size, return TryAllocateInFreshPage(size, HeapPage::kData, growth_policy, is_locked); } - intptr_t block_size = block->Size(); + intptr_t block_size = block->HeapSize(); if (remaining > 0) { if (is_locked) { freelist_[HeapPage::kData].FreeLocked(bump_top_, remaining); diff --git a/runtime/vm/heap/scavenger.cc b/runtime/vm/heap/scavenger.cc index 977a020253b..b6906aef7f8 100644 --- a/runtime/vm/heap/scavenger.cc +++ b/runtime/vm/heap/scavenger.cc @@ -134,7 +134,7 @@ class ScavengerVisitor : public ObjectPointerVisitor { // Get the new location of the object. new_addr = ForwardedAddr(header); } else { - intptr_t size = raw_obj->Size(); + intptr_t size = raw_obj->HeapSize(); NOT_IN_PRODUCT(intptr_t cid = raw_obj->GetClassId()); NOT_IN_PRODUCT(ClassTable* class_table = isolate()->class_table()); // Check whether object should be promoted. @@ -768,7 +768,7 @@ uword Scavenger::ProcessWeakProperty(RawWeakProperty* raw_weak, if (!IsForwarding(header)) { // Key is white. Enqueue the weak property. EnqueueWeakProperty(raw_weak); - return raw_weak->Size(); + return raw_weak->HeapSize(); } } // Key is gray or black. Make the weak property black. @@ -892,7 +892,7 @@ void Scavenger::VisitObjects(ObjectVisitor* visitor) const { while (cur < top_) { RawObject* raw_obj = RawObject::FromAddr(cur); visitor->VisitObject(raw_obj); - cur += raw_obj->Size(); + cur += raw_obj->HeapSize(); } } @@ -907,7 +907,7 @@ RawObject* Scavenger::FindObject(FindObjectVisitor* visitor) const { if (visitor->VisitRange(cur, top_)) { while (cur < top_) { RawObject* raw_obj = RawObject::FromAddr(cur); - uword next = cur + raw_obj->Size(); + uword next = cur + raw_obj->HeapSize(); if (visitor->VisitRange(cur, next) && raw_obj->FindObject(visitor)) { return raw_obj; // Found object, return it. } diff --git a/runtime/vm/heap/sweeper.cc b/runtime/vm/heap/sweeper.cc index 74740099972..b1e385fadf5 100644 --- a/runtime/vm/heap/sweeper.cc +++ b/runtime/vm/heap/sweeper.cc @@ -34,10 +34,10 @@ bool GCSweeper::SweepPage(HeapPage* page, FreeList* freelist, bool locked) { if (raw_obj->IsMarked()) { // Found marked object. Clear the mark bit and update swept bytes. raw_obj->ClearMarkBit(); - obj_size = raw_obj->Size(); + obj_size = raw_obj->HeapSize(); used_in_bytes += obj_size; } else { - uword free_end = current + raw_obj->Size(); + uword free_end = current + raw_obj->HeapSize(); while (free_end < end) { RawObject* next_obj = RawObject::FromAddr(free_end); if (next_obj->IsMarked()) { @@ -45,7 +45,7 @@ bool GCSweeper::SweepPage(HeapPage* page, FreeList* freelist, bool locked) { break; } // Expand the free block by the size of this object. - free_end += next_obj->Size(); + free_end += next_obj->HeapSize(); } obj_size = free_end - current; if (is_executable) { @@ -86,17 +86,17 @@ intptr_t GCSweeper::SweepLargePage(HeapPage* page) { ASSERT(HeapPage::Of(raw_obj) == page); if (raw_obj->IsMarked()) { raw_obj->ClearMarkBit(); - words_to_end = (raw_obj->Size() >> kWordSizeLog2); + words_to_end = (raw_obj->HeapSize() >> kWordSizeLog2); } #ifdef DEBUG // String::MakeExternal and Array::MakeFixedLength create trailing filler // objects, but they are always unreachable. Verify that they are not marked. - uword current = RawObject::ToAddr(raw_obj) + raw_obj->Size(); + uword current = RawObject::ToAddr(raw_obj) + raw_obj->HeapSize(); uword end = page->object_end(); while (current < end) { RawObject* cur_obj = RawObject::FromAddr(current); ASSERT(!cur_obj->IsMarked()); - intptr_t obj_size = cur_obj->Size(); + intptr_t obj_size = cur_obj->HeapSize(); memset(reinterpret_cast(current), Heap::kZapByte, obj_size); current += obj_size; } diff --git a/runtime/vm/image_snapshot.cc b/runtime/vm/image_snapshot.cc index c95df4738c7..838e2b7fa01 100644 --- a/runtime/vm/image_snapshot.cc +++ b/runtime/vm/image_snapshot.cc @@ -43,7 +43,7 @@ intptr_t ObjectOffsetTrait::Hashcode(Key key) { ASSERT(!obj->IsSmi()); uword body = RawObject::ToAddr(obj) + sizeof(RawObject); - uword end = RawObject::ToAddr(obj) + obj->Size(); + uword end = RawObject::ToAddr(obj) + obj->HeapSize(); uint32_t hash = obj->GetClassId(); // Don't include the header. Objects in the image are pre-marked, but objects @@ -65,8 +65,8 @@ bool ObjectOffsetTrait::IsKeyEqual(Pair pair, Key key) { return false; } - intptr_t heap_size = a->Size(); - if (b->Size() != heap_size) { + intptr_t heap_size = a->HeapSize(); + if (b->HeapSize() != heap_size) { return false; } @@ -106,7 +106,7 @@ void ImageWriter::PrepareForSerialization( RawInstructions* instructions = Code::InstructionsOf(code); const intptr_t offset = next_text_offset_; instructions_.Add(InstructionsData(instructions, code, offset)); - next_text_offset_ += instructions->Size(); + next_text_offset_ += instructions->HeapSize(); ASSERT(heap_->GetObjectId(instructions) == 0); heap_->SetObjectId(instructions, offset); break; @@ -141,7 +141,7 @@ void ImageWriter::SetupShared(ObjectOffsetMap* map, const void* shared_image) { pair.object = raw_obj; pair.offset = offset; map->Insert(pair); - obj_addr += raw_obj->Size(); + obj_addr += raw_obj->HeapSize(); } ASSERT(obj_addr == end_addr); } @@ -172,7 +172,7 @@ int32_t ImageWriter::GetTextOffsetFor(RawInstructions* instructions, offset = next_text_offset_; heap_->SetObjectId(instructions, offset); - next_text_offset_ += instructions->Size(); + next_text_offset_ += instructions->HeapSize(); instructions_.Add(InstructionsData(instructions, code, offset)); return offset; @@ -189,7 +189,7 @@ bool ImageWriter::GetSharedDataOffsetFor(RawObject* raw_object, } uint32_t ImageWriter::GetDataOffsetFor(RawObject* raw_object) { - intptr_t heap_size = raw_object->Size(); + intptr_t heap_size = raw_object->HeapSize(); intptr_t offset = next_data_offset_; next_data_offset_ += heap_size; objects_.Add(ObjectData(raw_object)); @@ -223,11 +223,6 @@ void ImageWriter::DumpInstructionsSizes() { js.OpenArray(); for (intptr_t i = 0; i < instructions_.length(); i++) { auto& data = instructions_[i]; - if (data.code_->IsNull()) { - // TODO(34650): Type testing stubs are added to the serializer without - // their Code. - continue; - } owner = data.code_->owner(); js.OpenObject(); if (owner.IsFunction()) { @@ -239,7 +234,7 @@ void ImageWriter::DumpInstructionsSizes() { js.PrintPropertyStr("c", name); } js.PrintProperty("n", data.code_->QualifiedName()); - js.PrintProperty("s", data.insns_->raw()->Size()); + js.PrintProperty("s", data.insns_->raw()->HeapSize()); js.CloseObject(); } js.CloseArray(); @@ -334,7 +329,7 @@ void ImageWriter::WriteROData(WriteStream* stream) { NoSafepointScope no_safepoint; uword start = reinterpret_cast(obj.raw()) - kHeapObjectTag; - uword end = start + obj.raw()->Size(); + uword end = start + obj.raw()->HeapSize(); // Write object header with the mark and VM heap bits set. uword marked_tags = obj.raw()->ptr()->tags_; @@ -475,10 +470,10 @@ void AssemblyImageWriter::WriteText(WriteStream* clustered_stream, bool vm) { "Instructions", /*name=*/nullptr); profile_writer_->AttributeBytesTo({offset_space_, offset}, - insns.raw()->Size()); + insns.raw()->HeapSize()); } - ASSERT(insns.raw()->Size() % sizeof(uint64_t) == 0); + ASSERT(insns.raw()->HeapSize() % sizeof(uint64_t) == 0); // 1. Write from the header to the entry point. { @@ -554,7 +549,7 @@ void AssemblyImageWriter::WriteText(WriteStream* clustered_stream, bool vm) { NoSafepointScope no_safepoint; uword beginning = reinterpret_cast(insns.raw_ptr()); uword entry = beginning + Instructions::HeaderSize(); - uword payload_size = insns.raw()->Size() - insns.HeaderSize(); + uword payload_size = insns.raw()->HeapSize() - insns.HeaderSize(); uword end = entry + payload_size; ASSERT(Utils::IsAligned(beginning, sizeof(uword))); @@ -564,7 +559,7 @@ void AssemblyImageWriter::WriteText(WriteStream* clustered_stream, bool vm) { text_offset += WriteByteSequence(entry, end); } - ASSERT((text_offset - instr_start) == insns.raw()->Size()); + ASSERT((text_offset - instr_start) == insns.raw()->HeapSize()); } FrameUnwindEpilogue(); @@ -755,7 +750,7 @@ void BlobImageWriter::WriteText(WriteStream* clustered_stream, bool vm) { beginning += sizeof(uword); text_offset += WriteByteSequence(beginning, end); - ASSERT((text_offset - instr_start) == insns.raw()->Size()); + ASSERT((text_offset - instr_start) == insns.raw()->HeapSize()); } } diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc index 5925d874cdd..fd996b882cf 100644 --- a/runtime/vm/object.cc +++ b/runtime/vm/object.cc @@ -1119,9 +1119,9 @@ void Object::FinalizeReadOnlyObject(RawObject* object) { String::SetCachedHash(str, hash); } intptr_t size = OneByteString::UnroundedSize(str); - ASSERT(size <= str->Size()); + ASSERT(size <= str->HeapSize()); memset(reinterpret_cast(RawObject::ToAddr(str) + size), 0, - str->Size() - size); + str->HeapSize() - size); } else if (cid == kTwoByteStringCid) { RawTwoByteString* str = static_cast(object); if (String::GetCachedHash(str) == 0) { @@ -1130,9 +1130,9 @@ void Object::FinalizeReadOnlyObject(RawObject* object) { } ASSERT(String::GetCachedHash(str) != 0); intptr_t size = TwoByteString::UnroundedSize(str); - ASSERT(size <= str->Size()); + ASSERT(size <= str->HeapSize()); memset(reinterpret_cast(RawObject::ToAddr(str) + size), 0, - str->Size() - size); + str->HeapSize() - size); } else if (cid == kExternalOneByteStringCid) { RawExternalOneByteString* str = static_cast(object); @@ -1150,21 +1150,21 @@ void Object::FinalizeReadOnlyObject(RawObject* object) { } else if (cid == kCodeSourceMapCid) { RawCodeSourceMap* map = CodeSourceMap::RawCast(object); intptr_t size = CodeSourceMap::UnroundedSize(map); - ASSERT(size <= map->Size()); + ASSERT(size <= map->HeapSize()); memset(reinterpret_cast(RawObject::ToAddr(map) + size), 0, - map->Size() - size); + map->HeapSize() - size); } else if (cid == kStackMapCid) { RawStackMap* map = StackMap::RawCast(object); intptr_t size = StackMap::UnroundedSize(map); - ASSERT(size <= map->Size()); + ASSERT(size <= map->HeapSize()); memset(reinterpret_cast(RawObject::ToAddr(map) + size), 0, - map->Size() - size); + map->HeapSize() - size); } else if (cid == kPcDescriptorsCid) { RawPcDescriptors* desc = PcDescriptors::RawCast(object); intptr_t size = PcDescriptors::UnroundedSize(desc); - ASSERT(size <= desc->Size()); + ASSERT(size <= desc->HeapSize()); memset(reinterpret_cast(RawObject::ToAddr(desc) + size), 0, - desc->Size() - size); + desc->HeapSize() - size); } } @@ -2120,7 +2120,7 @@ bool Object::IsNotTemporaryScopedHandle() const { RawObject* Object::Clone(const Object& orig, Heap::Space space) { const Class& cls = Class::Handle(orig.clazz()); - intptr_t size = orig.raw()->Size(); + intptr_t size = orig.raw()->HeapSize(); RawObject* raw_clone = Object::Allocate(cls.id(), size, space); NoSafepointScope no_safepoint; // Copy the body of the original into the clone. @@ -14464,7 +14464,8 @@ RawCode* Code::FinalizeCode(const char* name, if (FLAG_write_protect_code) { uword address = RawObject::ToAddr(instrs.raw()); VirtualMemory::Protect(reinterpret_cast(address), - instrs.raw()->Size(), VirtualMemory::kReadExecute); + instrs.raw()->HeapSize(), + VirtualMemory::kReadExecute); } } CPU::FlushICache(instrs.PayloadStart(), instrs.Size()); @@ -20065,7 +20066,7 @@ uint32_t Array::CanonicalizeHash() const { RawArray* Array::New(intptr_t len, Heap::Space space) { ASSERT(Isolate::Current()->object_store()->array_class() != Class::null()); RawArray* result = New(kClassId, len, space); - if (result->Size() > Heap::kNewAllocatableSize) { + if (result->HeapSize() > Heap::kNewAllocatableSize) { ASSERT(result->IsOldObject()); result->SetCardRememberedBitUnsynchronized(); } diff --git a/runtime/vm/object_graph.cc b/runtime/vm/object_graph.cc index 6edb4246706..6b7cda35a76 100644 --- a/runtime/vm/object_graph.cc +++ b/runtime/vm/object_graph.cc @@ -135,7 +135,7 @@ intptr_t ObjectGraph::StackIterator::OffsetFromParentInWords() const { ASSERT(child.obj == *child.ptr); uword child_ptr_addr = reinterpret_cast(child.ptr); intptr_t offset = child_ptr_addr - parent_start; - if (offset > 0 && offset < parent.obj->Size()) { + if (offset > 0 && offset < parent.obj->HeapSize()) { ASSERT(Utils::IsAligned(offset, kWordSize)); return offset >> kWordSizeLog2; } else { @@ -272,7 +272,7 @@ class SizeVisitor : public ObjectGraph::Visitor { if (ShouldSkip(obj)) { return kBacktrack; } - size_ += obj->Size(); + size_ += obj->HeapSize(); return kProceed; } @@ -475,7 +475,7 @@ class InboundReferencesVisitor : public ObjectVisitor, uword source_start = RawObject::ToAddr(source_); uword current_ptr_addr = reinterpret_cast(current_ptr); intptr_t offset = current_ptr_addr - source_start; - if (offset > 0 && offset < source_->Size()) { + if (offset > 0 && offset < source_->HeapSize()) { ASSERT(Utils::IsAligned(offset, kWordSize)); *scratch_ = Smi::New(offset >> kWordSizeLog2); } else { @@ -583,7 +583,7 @@ class WriteGraphVisitor : public ObjectGraph::Visitor { if ((roots_ == ObjectGraph::kVM) || obj.IsField() || obj.IsInstance() || obj.IsContext()) { // Each object is a header + a zero-terminated list of its neighbors. - WriteHeader(raw_obj, raw_obj->Size(), obj.GetClassId(), stream_); + WriteHeader(raw_obj, raw_obj->HeapSize(), obj.GetClassId(), stream_); raw_obj->VisitPointers(&ptr_writer_); stream_->WriteUnsigned(0); ++count_; diff --git a/runtime/vm/object_graph_test.cc b/runtime/vm/object_graph_test.cc index 72cffefb856..c4f1515426f 100644 --- a/runtime/vm/object_graph_test.cc +++ b/runtime/vm/object_graph_test.cc @@ -23,7 +23,7 @@ class CounterVisitor : public ObjectGraph::Visitor { return kBacktrack; } ++count_; - size_ += obj->Size(); + size_ += obj->HeapSize(); return kProceed; } @@ -52,10 +52,10 @@ ISOLATE_UNIT_TEST_CASE(ObjectGraph) { b.SetAt(0, c); b.SetAt(1, d); a.SetAt(11, d); - intptr_t a_size = a.raw()->Size(); - intptr_t b_size = b.raw()->Size(); - intptr_t c_size = c.raw()->Size(); - intptr_t d_size = d.raw()->Size(); + intptr_t a_size = a.raw()->HeapSize(); + intptr_t b_size = b.raw()->HeapSize(); + intptr_t c_size = c.raw()->HeapSize(); + intptr_t d_size = d.raw()->HeapSize(); { // No more allocation; raw pointers ahead. SafepointOperationScope safepoint(thread); diff --git a/runtime/vm/object_service.cc b/runtime/vm/object_service.cc index c0c1152aba4..74cf6685abf 100644 --- a/runtime/vm/object_service.cc +++ b/runtime/vm/object_service.cc @@ -43,7 +43,7 @@ void Object::AddCommonObjectProperties(JSONObject* jsobj, } if (!ref) { if (raw()->IsHeapObject()) { - jsobj->AddProperty("size", raw()->Size()); + jsobj->AddProperty("size", raw()->HeapSize()); } else { jsobj->AddProperty("size", (intptr_t)0); } diff --git a/runtime/vm/raw_object.cc b/runtime/vm/raw_object.cc index 63921251546..76a82859b4a 100644 --- a/runtime/vm/raw_object.cc +++ b/runtime/vm/raw_object.cc @@ -62,7 +62,7 @@ void RawObject::Validate(Isolate* isolate) const { return; } intptr_t size_from_tags = SizeTag::decode(tags); - intptr_t size_from_class = SizeFromClass(); + intptr_t size_from_class = HeapSizeFromClass(); if ((size_from_tags != 0) && (size_from_tags != size_from_class)) { FATAL3( "Inconsistent size encountered " @@ -74,7 +74,7 @@ void RawObject::Validate(Isolate* isolate) const { // Can't look at the class object because it can be called during // compaction when the class objects are moving. Can use the class // id in the header and the sizes in the Class Table. -intptr_t RawObject::SizeFromClass() const { +intptr_t RawObject::HeapSizeFromClass() const { // Only reasonable to be called on heap objects. ASSERT(IsHeapObject()); @@ -191,13 +191,13 @@ intptr_t RawObject::SizeFromClass() const { case kFreeListElement: { uword addr = RawObject::ToAddr(this); FreeListElement* element = reinterpret_cast(addr); - instance_size = element->Size(); + instance_size = element->HeapSize(); break; } case kForwardingCorpse: { uword addr = RawObject::ToAddr(this); ForwardingCorpse* element = reinterpret_cast(addr); - instance_size = element->Size(); + instance_size = element->HeapSize(); break; } default: { @@ -285,17 +285,17 @@ intptr_t RawObject::VisitPointersPredefined(ObjectPointerVisitor* visitor, case kFreeListElement: { uword addr = RawObject::ToAddr(this); FreeListElement* element = reinterpret_cast(addr); - size = element->Size(); + size = element->HeapSize(); break; } case kForwardingCorpse: { uword addr = RawObject::ToAddr(this); ForwardingCorpse* forwarder = reinterpret_cast(addr); - size = forwarder->Size(); + size = forwarder->HeapSize(); break; } case kNullCid: - size = Size(); + size = HeapSize(); break; default: OS::PrintErr("Class Id: %" Pd "\n", class_id); @@ -305,13 +305,13 @@ intptr_t RawObject::VisitPointersPredefined(ObjectPointerVisitor* visitor, #if defined(DEBUG) ASSERT(size != 0); - const intptr_t expected_size = Size(); + const intptr_t expected_size = HeapSize(); - // In general we expect that visitors return exactly the same size that Size - // would compute. However in case of Arrays we might have a discrepancy when - // concurrently visiting an array that is being shrunk with + // In general we expect that visitors return exactly the same size that + // HeapSize would compute. However in case of Arrays we might have a + // discrepancy when concurrently visiting an array that is being shrunk with // Array::MakeFixedLength: the visitor might have visited the full array while - // here we are observing a smaller Size(). + // here we are observing a smaller HeapSize(). ASSERT(size == expected_size || (class_id == kArrayCid && size > expected_size)); return size; // Prefer larger size. diff --git a/runtime/vm/raw_object.h b/runtime/vm/raw_object.h index 400ec1d10cc..db34db3c589 100644 --- a/runtime/vm/raw_object.h +++ b/runtime/vm/raw_object.h @@ -363,17 +363,18 @@ class RawObject { return IsHeapObject() ? GetClassId() : static_cast(kSmiCid); } - intptr_t Size() const { + intptr_t HeapSize() const { + ASSERT(IsHeapObject()); uint32_t tags = ptr()->tags_; intptr_t result = SizeTag::decode(tags); if (result != 0) { #if defined(DEBUG) // TODO(22501) Array::MakeFixedLength has a race with this code: we might // have loaded tags field and then MakeFixedLength could have updated it - // leading to inconsistency between SizeFromClass() and + // leading to inconsistency between HeapSizeFromClass() and // SizeTag::decode(tags). We are working around it by reloading tags_ and // recomputing size from tags. - const intptr_t size_from_class = SizeFromClass(); + const intptr_t size_from_class = HeapSizeFromClass(); if ((result > size_from_class) && (GetClassId() == kArrayCid) && (ptr()->tags_ != tags)) { result = SizeTag::decode(ptr()->tags_); @@ -382,13 +383,13 @@ class RawObject { #endif return result; } - result = SizeFromClass(); + result = HeapSizeFromClass(); ASSERT(result > SizeTag::kMaxSizeTag); return result; } bool Contains(uword addr) const { - intptr_t this_size = Size(); + intptr_t this_size = HeapSize(); uword this_addr = RawObject::ToAddr(this); return (addr >= this_addr) && (addr < (this_addr + this_size)); } @@ -407,7 +408,7 @@ class RawObject { } // Calculate the first and last raw object pointer fields. - intptr_t instance_size = Size(); + intptr_t instance_size = HeapSize(); uword obj_addr = ToAddr(this); uword from = obj_addr + sizeof(RawObject); uword to = obj_addr + instance_size - kWordSize; @@ -428,7 +429,7 @@ class RawObject { } // Calculate the first and last raw object pointer fields. - intptr_t instance_size = Size(); + intptr_t instance_size = HeapSize(); uword obj_addr = ToAddr(this); uword from = obj_addr + sizeof(RawObject); uword to = obj_addr + instance_size - kWordSize; @@ -493,7 +494,7 @@ class RawObject { intptr_t VisitPointersPredefined(ObjectPointerVisitor* visitor, intptr_t class_id); - intptr_t SizeFromClass() const; + intptr_t HeapSizeFromClass() const; intptr_t GetClassId() const { uint32_t tags = ptr()->tags_; diff --git a/runtime/vm/service.cc b/runtime/vm/service.cc index 801a02a41af..63aa9b99817 100644 --- a/runtime/vm/service.cc +++ b/runtime/vm/service.cc @@ -4108,7 +4108,7 @@ class ContainsAddressVisitor : public FindObjectVisitor { return false; } uword obj_begin = RawObject::ToAddr(obj); - uword obj_end = obj_begin + obj->Size(); + uword obj_end = obj_begin + obj->HeapSize(); return obj_begin <= addr_ && addr_ < obj_end; }