1 /* 2 * Copyright (C) 2014 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include "remembered_set.h" 18 19 #include <memory> 20 21 #include "base/stl_util.h" 22 #include "card_table-inl.h" 23 #include "heap_bitmap.h" 24 #include "gc/collector/mark_sweep.h" 25 #include "gc/collector/mark_sweep-inl.h" 26 #include "gc/collector/semi_space.h" 27 #include "gc/heap.h" 28 #include "gc/space/space.h" 29 #include "mirror/class-inl.h" 30 #include "mirror/object-inl.h" 31 #include "mirror/object-refvisitor-inl.h" 32 #include "mirror/object_array-inl.h" 33 #include "space_bitmap-inl.h" 34 #include "thread.h" 35 36 namespace art { 37 namespace gc { 38 namespace accounting { 39 40 class RememberedSetCardVisitor { 41 public: 42 explicit RememberedSetCardVisitor(RememberedSet::CardSet* const dirty_cards) 43 : dirty_cards_(dirty_cards) {} 44 45 void operator()(uint8_t* card, uint8_t expected_value, uint8_t new_value ATTRIBUTE_UNUSED) const { 46 if (expected_value == CardTable::kCardDirty) { 47 dirty_cards_->insert(card); 48 } 49 } 50 51 private: 52 RememberedSet::CardSet* const dirty_cards_; 53 }; 54 55 void RememberedSet::ClearCards() { 56 CardTable* card_table = GetHeap()->GetCardTable(); 57 RememberedSetCardVisitor card_visitor(&dirty_cards_); 58 // Clear dirty cards in the space and insert them into the dirty card set. 59 card_table->ModifyCardsAtomic(space_->Begin(), space_->End(), AgeCardVisitor(), card_visitor); 60 } 61 62 class RememberedSetReferenceVisitor { 63 public: 64 RememberedSetReferenceVisitor(space::ContinuousSpace* target_space, 65 bool* const contains_reference_to_target_space, 66 collector::GarbageCollector* collector) 67 : collector_(collector), target_space_(target_space), 68 contains_reference_to_target_space_(contains_reference_to_target_space) {} 69 70 void operator()(ObjPtr<mirror::Object> obj, 71 MemberOffset offset, 72 bool is_static ATTRIBUTE_UNUSED) const 73 REQUIRES_SHARED(Locks::mutator_lock_) { 74 DCHECK(obj != nullptr); 75 mirror::HeapReference<mirror::Object>* ref_ptr = obj->GetFieldObjectReferenceAddr(offset); 76 if (target_space_->HasAddress(ref_ptr->AsMirrorPtr())) { 77 *contains_reference_to_target_space_ = true; 78 collector_->MarkHeapReference(ref_ptr, /*do_atomic_update*/ false); 79 DCHECK(!target_space_->HasAddress(ref_ptr->AsMirrorPtr())); 80 } 81 } 82 83 void operator()(ObjPtr<mirror::Class> klass, ObjPtr<mirror::Reference> ref) const 84 REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(Locks::heap_bitmap_lock_) { 85 if (target_space_->HasAddress(ref->GetReferent())) { 86 *contains_reference_to_target_space_ = true; 87 collector_->DelayReferenceReferent(klass, ref); 88 } 89 } 90 91 void VisitRootIfNonNull(mirror::CompressedReference<mirror::Object>* root) const 92 REQUIRES_SHARED(Locks::mutator_lock_) { 93 if (!root->IsNull()) { 94 VisitRoot(root); 95 } 96 } 97 98 void VisitRoot(mirror::CompressedReference<mirror::Object>* root) const 99 REQUIRES_SHARED(Locks::mutator_lock_) { 100 if (target_space_->HasAddress(root->AsMirrorPtr())) { 101 *contains_reference_to_target_space_ = true; 102 root->Assign(collector_->MarkObject(root->AsMirrorPtr())); 103 DCHECK(!target_space_->HasAddress(root->AsMirrorPtr())); 104 } 105 } 106 107 private: 108 collector::GarbageCollector* const collector_; 109 space::ContinuousSpace* const target_space_; 110 bool* const contains_reference_to_target_space_; 111 }; 112 113 class RememberedSetObjectVisitor { 114 public: 115 RememberedSetObjectVisitor(space::ContinuousSpace* target_space, 116 bool* const contains_reference_to_target_space, 117 collector::GarbageCollector* collector) 118 : collector_(collector), target_space_(target_space), 119 contains_reference_to_target_space_(contains_reference_to_target_space) {} 120 121 void operator()(ObjPtr<mirror::Object> obj) const REQUIRES(Locks::heap_bitmap_lock_) 122 REQUIRES_SHARED(Locks::mutator_lock_) { 123 RememberedSetReferenceVisitor visitor(target_space_, contains_reference_to_target_space_, 124 collector_); 125 obj->VisitReferences(visitor, visitor); 126 } 127 128 private: 129 collector::GarbageCollector* const collector_; 130 space::ContinuousSpace* const target_space_; 131 bool* const contains_reference_to_target_space_; 132 }; 133 134 void RememberedSet::UpdateAndMarkReferences(space::ContinuousSpace* target_space, 135 collector::GarbageCollector* collector) { 136 CardTable* card_table = heap_->GetCardTable(); 137 bool contains_reference_to_target_space = false; 138 RememberedSetObjectVisitor obj_visitor(target_space, &contains_reference_to_target_space, 139 collector); 140 ContinuousSpaceBitmap* bitmap = space_->GetLiveBitmap(); 141 CardSet remove_card_set; 142 for (uint8_t* const card_addr : dirty_cards_) { 143 contains_reference_to_target_space = false; 144 uintptr_t start = reinterpret_cast<uintptr_t>(card_table->AddrFromCard(card_addr)); 145 DCHECK(space_->HasAddress(reinterpret_cast<mirror::Object*>(start))); 146 bitmap->VisitMarkedRange(start, start + CardTable::kCardSize, obj_visitor); 147 if (!contains_reference_to_target_space) { 148 // It was in the dirty card set, but it didn't actually contain 149 // a reference to the target space. So, remove it from the dirty 150 // card set so we won't have to scan it again (unless it gets 151 // dirty again.) 152 remove_card_set.insert(card_addr); 153 } 154 } 155 156 // Remove the cards that didn't contain a reference to the target 157 // space from the dirty card set. 158 for (uint8_t* const card_addr : remove_card_set) { 159 DCHECK(dirty_cards_.find(card_addr) != dirty_cards_.end()); 160 dirty_cards_.erase(card_addr); 161 } 162 } 163 164 void RememberedSet::Dump(std::ostream& os) { 165 CardTable* card_table = heap_->GetCardTable(); 166 os << "RememberedSet dirty cards: ["; 167 for (const uint8_t* card_addr : dirty_cards_) { 168 auto start = reinterpret_cast<uintptr_t>(card_table->AddrFromCard(card_addr)); 169 auto end = start + CardTable::kCardSize; 170 os << reinterpret_cast<void*>(start) << "-" << reinterpret_cast<void*>(end) << "\n"; 171 } 172 os << "]"; 173 } 174 175 void RememberedSet::AssertAllDirtyCardsAreWithinSpace() const { 176 CardTable* card_table = heap_->GetCardTable(); 177 for (const uint8_t* card_addr : dirty_cards_) { 178 auto start = reinterpret_cast<uint8_t*>(card_table->AddrFromCard(card_addr)); 179 auto end = start + CardTable::kCardSize; 180 DCHECK_LE(space_->Begin(), start); 181 DCHECK_LE(end, space_->Limit()); 182 } 183 } 184 185 } // namespace accounting 186 } // namespace gc 187 } // namespace art 188