Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2012 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 "mod_union_table.h" |
| 18 | |
Ian Rogers | 700a402 | 2014-05-19 16:49:03 -0700 | [diff] [blame^] | 19 | #include <memory> |
| 20 | |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 21 | #include "base/stl_util.h" |
| 22 | #include "card_table-inl.h" |
| 23 | #include "heap_bitmap.h" |
Mathieu Chartier | a8e8f9c | 2014-04-09 14:51:05 -0700 | [diff] [blame] | 24 | #include "gc/accounting/space_bitmap-inl.h" |
Mathieu Chartier | 11409ae | 2013-09-23 11:49:36 -0700 | [diff] [blame] | 25 | #include "gc/collector/mark_sweep.h" |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 26 | #include "gc/collector/mark_sweep-inl.h" |
| 27 | #include "gc/heap.h" |
| 28 | #include "gc/space/space.h" |
Brian Carlstrom | ea46f95 | 2013-07-30 01:26:50 -0700 | [diff] [blame] | 29 | #include "mirror/art_field-inl.h" |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 30 | #include "mirror/object-inl.h" |
| 31 | #include "mirror/class-inl.h" |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 32 | #include "mirror/object_array-inl.h" |
| 33 | #include "space_bitmap-inl.h" |
| 34 | #include "thread.h" |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 35 | |
Brian Carlstrom | 3e3d591 | 2013-07-18 00:19:45 -0700 | [diff] [blame] | 36 | using ::art::mirror::Object; |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 37 | |
| 38 | namespace art { |
| 39 | namespace gc { |
| 40 | namespace accounting { |
| 41 | |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 42 | class ModUnionClearCardSetVisitor { |
| 43 | public: |
Mathieu Chartier | 0a9dc05 | 2013-07-25 11:01:28 -0700 | [diff] [blame] | 44 | explicit ModUnionClearCardSetVisitor(ModUnionTable::CardSet* const cleared_cards) |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 45 | : cleared_cards_(cleared_cards) { |
| 46 | } |
| 47 | |
Brian Carlstrom | df62950 | 2013-07-17 22:39:56 -0700 | [diff] [blame] | 48 | inline void operator()(byte* card, byte expected_value, byte new_value) const { |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 49 | if (expected_value == CardTable::kCardDirty) { |
| 50 | cleared_cards_->insert(card); |
| 51 | } |
| 52 | } |
| 53 | |
| 54 | private: |
Mathieu Chartier | 0a9dc05 | 2013-07-25 11:01:28 -0700 | [diff] [blame] | 55 | ModUnionTable::CardSet* const cleared_cards_; |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 56 | }; |
| 57 | |
| 58 | class ModUnionClearCardVisitor { |
| 59 | public: |
| 60 | explicit ModUnionClearCardVisitor(std::vector<byte*>* cleared_cards) |
| 61 | : cleared_cards_(cleared_cards) { |
| 62 | } |
| 63 | |
Brian Carlstrom | df62950 | 2013-07-17 22:39:56 -0700 | [diff] [blame] | 64 | void operator()(byte* card, byte expected_card, byte new_card) const { |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 65 | if (expected_card == CardTable::kCardDirty) { |
| 66 | cleared_cards_->push_back(card); |
| 67 | } |
| 68 | } |
| 69 | private: |
| 70 | std::vector<byte*>* const cleared_cards_; |
| 71 | }; |
| 72 | |
Mathieu Chartier | 11409ae | 2013-09-23 11:49:36 -0700 | [diff] [blame] | 73 | class ModUnionUpdateObjectReferencesVisitor { |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 74 | public: |
Mathieu Chartier | 407f702 | 2014-02-18 14:37:05 -0800 | [diff] [blame] | 75 | ModUnionUpdateObjectReferencesVisitor(MarkHeapReferenceCallback* callback, void* arg) |
Mathieu Chartier | 83c8ee0 | 2014-01-28 14:50:23 -0800 | [diff] [blame] | 76 | : callback_(callback), |
Mathieu Chartier | 11409ae | 2013-09-23 11:49:36 -0700 | [diff] [blame] | 77 | arg_(arg) { |
| 78 | } |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 79 | |
Mathieu Chartier | 11409ae | 2013-09-23 11:49:36 -0700 | [diff] [blame] | 80 | // Extra parameters are required since we use this same visitor signature for checking objects. |
Mathieu Chartier | 4aeec17 | 2014-03-27 16:09:46 -0700 | [diff] [blame] | 81 | void operator()(Object* obj, MemberOffset offset, bool /*is_static*/) const |
Mathieu Chartier | 407f702 | 2014-02-18 14:37:05 -0800 | [diff] [blame] | 82 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { |
Mathieu Chartier | 11409ae | 2013-09-23 11:49:36 -0700 | [diff] [blame] | 83 | // Only add the reference if it is non null and fits our criteria. |
Mathieu Chartier | 407f702 | 2014-02-18 14:37:05 -0800 | [diff] [blame] | 84 | mirror::HeapReference<Object>* obj_ptr = obj->GetFieldObjectReferenceAddr(offset); |
| 85 | if (obj_ptr->AsMirrorPtr() != nullptr) { |
| 86 | callback_(obj_ptr, arg_); |
Mathieu Chartier | 11409ae | 2013-09-23 11:49:36 -0700 | [diff] [blame] | 87 | } |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 88 | } |
| 89 | |
| 90 | private: |
Mathieu Chartier | 407f702 | 2014-02-18 14:37:05 -0800 | [diff] [blame] | 91 | MarkHeapReferenceCallback* const callback_; |
Mathieu Chartier | 11409ae | 2013-09-23 11:49:36 -0700 | [diff] [blame] | 92 | void* arg_; |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 93 | }; |
| 94 | |
Mathieu Chartier | 11409ae | 2013-09-23 11:49:36 -0700 | [diff] [blame] | 95 | class ModUnionScanImageRootVisitor { |
| 96 | public: |
Mathieu Chartier | 407f702 | 2014-02-18 14:37:05 -0800 | [diff] [blame] | 97 | ModUnionScanImageRootVisitor(MarkHeapReferenceCallback* callback, void* arg) |
Mathieu Chartier | 83c8ee0 | 2014-01-28 14:50:23 -0800 | [diff] [blame] | 98 | : callback_(callback), arg_(arg) {} |
Mathieu Chartier | 11409ae | 2013-09-23 11:49:36 -0700 | [diff] [blame] | 99 | |
| 100 | void operator()(Object* root) const |
| 101 | EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_) |
| 102 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { |
| 103 | DCHECK(root != NULL); |
Mathieu Chartier | 83c8ee0 | 2014-01-28 14:50:23 -0800 | [diff] [blame] | 104 | ModUnionUpdateObjectReferencesVisitor ref_visitor(callback_, arg_); |
Ian Rogers | b0fa5dc | 2014-04-28 16:47:08 -0700 | [diff] [blame] | 105 | root->VisitReferences<kMovingClasses>(ref_visitor, VoidFunctor()); |
Mathieu Chartier | 11409ae | 2013-09-23 11:49:36 -0700 | [diff] [blame] | 106 | } |
| 107 | |
| 108 | private: |
Mathieu Chartier | 407f702 | 2014-02-18 14:37:05 -0800 | [diff] [blame] | 109 | MarkHeapReferenceCallback* const callback_; |
Mathieu Chartier | 83c8ee0 | 2014-01-28 14:50:23 -0800 | [diff] [blame] | 110 | void* const arg_; |
Mathieu Chartier | 11409ae | 2013-09-23 11:49:36 -0700 | [diff] [blame] | 111 | }; |
| 112 | |
| 113 | void ModUnionTableReferenceCache::ClearCards() { |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 114 | CardTable* card_table = GetHeap()->GetCardTable(); |
| 115 | ModUnionClearCardSetVisitor visitor(&cleared_cards_); |
| 116 | // Clear dirty cards in the this space and update the corresponding mod-union bits. |
Mathieu Chartier | 11409ae | 2013-09-23 11:49:36 -0700 | [diff] [blame] | 117 | card_table->ModifyCardsAtomic(space_->Begin(), space_->End(), AgeCardVisitor(), visitor); |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 118 | } |
| 119 | |
| 120 | class AddToReferenceArrayVisitor { |
| 121 | public: |
| 122 | explicit AddToReferenceArrayVisitor(ModUnionTableReferenceCache* mod_union_table, |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 123 | std::vector<mirror::HeapReference<Object>*>* references) |
| 124 | : mod_union_table_(mod_union_table), references_(references) { |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 125 | } |
| 126 | |
| 127 | // Extra parameters are required since we use this same visitor signature for checking objects. |
Mathieu Chartier | 4aeec17 | 2014-03-27 16:09:46 -0700 | [diff] [blame] | 128 | void operator()(Object* obj, MemberOffset offset, bool /*is_static*/) const |
Mathieu Chartier | 407f702 | 2014-02-18 14:37:05 -0800 | [diff] [blame] | 129 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { |
| 130 | mirror::HeapReference<Object>* ref_ptr = obj->GetFieldObjectReferenceAddr(offset); |
| 131 | mirror::Object* ref = ref_ptr->AsMirrorPtr(); |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 132 | // Only add the reference if it is non null and fits our criteria. |
Mathieu Chartier | 4aeec17 | 2014-03-27 16:09:46 -0700 | [diff] [blame] | 133 | if (ref != nullptr && mod_union_table_->ShouldAddReference(ref)) { |
Mathieu Chartier | 11409ae | 2013-09-23 11:49:36 -0700 | [diff] [blame] | 134 | // Push the adddress of the reference. |
Mathieu Chartier | 407f702 | 2014-02-18 14:37:05 -0800 | [diff] [blame] | 135 | references_->push_back(ref_ptr); |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 136 | } |
| 137 | } |
| 138 | |
| 139 | private: |
| 140 | ModUnionTableReferenceCache* const mod_union_table_; |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 141 | std::vector<mirror::HeapReference<Object>*>* const references_; |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 142 | }; |
| 143 | |
| 144 | class ModUnionReferenceVisitor { |
| 145 | public: |
| 146 | explicit ModUnionReferenceVisitor(ModUnionTableReferenceCache* const mod_union_table, |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 147 | std::vector<mirror::HeapReference<Object>*>* references) |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 148 | : mod_union_table_(mod_union_table), |
| 149 | references_(references) { |
| 150 | } |
| 151 | |
Mathieu Chartier | 11409ae | 2013-09-23 11:49:36 -0700 | [diff] [blame] | 152 | void operator()(Object* obj) const |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 153 | SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_) { |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 154 | // We don't have an early exit since we use the visitor pattern, an early |
| 155 | // exit should significantly speed this up. |
| 156 | AddToReferenceArrayVisitor visitor(mod_union_table_, references_); |
Ian Rogers | b0fa5dc | 2014-04-28 16:47:08 -0700 | [diff] [blame] | 157 | obj->VisitReferences<kMovingClasses>(visitor, VoidFunctor()); |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 158 | } |
| 159 | private: |
| 160 | ModUnionTableReferenceCache* const mod_union_table_; |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 161 | std::vector<mirror::HeapReference<Object>*>* const references_; |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 162 | }; |
| 163 | |
| 164 | class CheckReferenceVisitor { |
| 165 | public: |
| 166 | explicit CheckReferenceVisitor(ModUnionTableReferenceCache* mod_union_table, |
| 167 | const std::set<const Object*>& references) |
| 168 | : mod_union_table_(mod_union_table), |
| 169 | references_(references) { |
| 170 | } |
| 171 | |
| 172 | // Extra parameters are required since we use this same visitor signature for checking objects. |
Mathieu Chartier | 4aeec17 | 2014-03-27 16:09:46 -0700 | [diff] [blame] | 173 | void operator()(Object* obj, MemberOffset offset, bool /*is_static*/) const |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 174 | SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_) { |
Ian Rogers | b0fa5dc | 2014-04-28 16:47:08 -0700 | [diff] [blame] | 175 | mirror::Object* ref = obj->GetFieldObject<mirror::Object>(offset); |
Mathieu Chartier | 4aeec17 | 2014-03-27 16:09:46 -0700 | [diff] [blame] | 176 | if (ref != nullptr && mod_union_table_->ShouldAddReference(ref) && |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 177 | references_.find(ref) == references_.end()) { |
Mathieu Chartier | 407f702 | 2014-02-18 14:37:05 -0800 | [diff] [blame] | 178 | Heap* heap = mod_union_table_->GetHeap(); |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 179 | space::ContinuousSpace* from_space = heap->FindContinuousSpaceFromObject(obj, false); |
| 180 | space::ContinuousSpace* to_space = heap->FindContinuousSpaceFromObject(ref, false); |
Mathieu Chartier | 407f702 | 2014-02-18 14:37:05 -0800 | [diff] [blame] | 181 | LOG(INFO) << "Object " << reinterpret_cast<const void*>(obj) << "(" << PrettyTypeOf(obj) |
| 182 | << ")" << "References " << reinterpret_cast<const void*>(ref) << "(" << PrettyTypeOf(ref) |
| 183 | << ") without being in mod-union table"; |
| 184 | LOG(INFO) << "FromSpace " << from_space->GetName() << " type " |
| 185 | << from_space->GetGcRetentionPolicy(); |
| 186 | LOG(INFO) << "ToSpace " << to_space->GetName() << " type " |
| 187 | << to_space->GetGcRetentionPolicy(); |
| 188 | heap->DumpSpaces(); |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 189 | LOG(FATAL) << "FATAL ERROR"; |
| 190 | } |
| 191 | } |
| 192 | |
| 193 | private: |
| 194 | ModUnionTableReferenceCache* const mod_union_table_; |
| 195 | const std::set<const Object*>& references_; |
| 196 | }; |
| 197 | |
| 198 | class ModUnionCheckReferences { |
| 199 | public: |
Brian Carlstrom | df62950 | 2013-07-17 22:39:56 -0700 | [diff] [blame] | 200 | explicit ModUnionCheckReferences(ModUnionTableReferenceCache* mod_union_table, |
| 201 | const std::set<const Object*>& references) |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 202 | EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_) |
| 203 | : mod_union_table_(mod_union_table), references_(references) { |
| 204 | } |
| 205 | |
Mathieu Chartier | 11409ae | 2013-09-23 11:49:36 -0700 | [diff] [blame] | 206 | void operator()(Object* obj) const NO_THREAD_SAFETY_ANALYSIS { |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 207 | Locks::heap_bitmap_lock_->AssertSharedHeld(Thread::Current()); |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 208 | CheckReferenceVisitor visitor(mod_union_table_, references_); |
Ian Rogers | b0fa5dc | 2014-04-28 16:47:08 -0700 | [diff] [blame] | 209 | obj->VisitReferences<kMovingClasses>(visitor, VoidFunctor()); |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 210 | } |
| 211 | |
| 212 | private: |
| 213 | ModUnionTableReferenceCache* const mod_union_table_; |
| 214 | const std::set<const Object*>& references_; |
| 215 | }; |
| 216 | |
| 217 | void ModUnionTableReferenceCache::Verify() { |
| 218 | // Start by checking that everything in the mod union table is marked. |
Mathieu Chartier | 11409ae | 2013-09-23 11:49:36 -0700 | [diff] [blame] | 219 | for (const auto& ref_pair : references_) { |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 220 | for (mirror::HeapReference<Object>* ref : ref_pair.second) { |
| 221 | CHECK(heap_->IsLiveObjectLocked(ref->AsMirrorPtr())); |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 222 | } |
| 223 | } |
| 224 | |
| 225 | // Check the references of each clean card which is also in the mod union table. |
Mathieu Chartier | 11409ae | 2013-09-23 11:49:36 -0700 | [diff] [blame] | 226 | CardTable* card_table = heap_->GetCardTable(); |
Mathieu Chartier | a8e8f9c | 2014-04-09 14:51:05 -0700 | [diff] [blame] | 227 | ContinuousSpaceBitmap* live_bitmap = space_->GetLiveBitmap(); |
Mathieu Chartier | 11409ae | 2013-09-23 11:49:36 -0700 | [diff] [blame] | 228 | for (const auto& ref_pair : references_) { |
| 229 | const byte* card = ref_pair.first; |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 230 | if (*card == CardTable::kCardClean) { |
Mathieu Chartier | 11409ae | 2013-09-23 11:49:36 -0700 | [diff] [blame] | 231 | std::set<const Object*> reference_set; |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 232 | for (mirror::HeapReference<Object>* obj_ptr : ref_pair.second) { |
| 233 | reference_set.insert(obj_ptr->AsMirrorPtr()); |
Mathieu Chartier | 11409ae | 2013-09-23 11:49:36 -0700 | [diff] [blame] | 234 | } |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 235 | ModUnionCheckReferences visitor(this, reference_set); |
| 236 | uintptr_t start = reinterpret_cast<uintptr_t>(card_table->AddrFromCard(card)); |
Mathieu Chartier | 11409ae | 2013-09-23 11:49:36 -0700 | [diff] [blame] | 237 | live_bitmap->VisitMarkedRange(start, start + CardTable::kCardSize, visitor); |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 238 | } |
| 239 | } |
| 240 | } |
| 241 | |
| 242 | void ModUnionTableReferenceCache::Dump(std::ostream& os) { |
| 243 | CardTable* card_table = heap_->GetCardTable(); |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 244 | os << "ModUnionTable cleared cards: ["; |
Mathieu Chartier | 02e2511 | 2013-08-14 16:14:24 -0700 | [diff] [blame] | 245 | for (byte* card_addr : cleared_cards_) { |
| 246 | uintptr_t start = reinterpret_cast<uintptr_t>(card_table->AddrFromCard(card_addr)); |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 247 | uintptr_t end = start + CardTable::kCardSize; |
| 248 | os << reinterpret_cast<void*>(start) << "-" << reinterpret_cast<void*>(end) << ","; |
| 249 | } |
| 250 | os << "]\nModUnionTable references: ["; |
Mathieu Chartier | 11409ae | 2013-09-23 11:49:36 -0700 | [diff] [blame] | 251 | for (const auto& ref_pair : references_) { |
| 252 | const byte* card_addr = ref_pair.first; |
Mathieu Chartier | 02e2511 | 2013-08-14 16:14:24 -0700 | [diff] [blame] | 253 | uintptr_t start = reinterpret_cast<uintptr_t>(card_table->AddrFromCard(card_addr)); |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 254 | uintptr_t end = start + CardTable::kCardSize; |
| 255 | os << reinterpret_cast<void*>(start) << "-" << reinterpret_cast<void*>(end) << "->{"; |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 256 | for (mirror::HeapReference<Object>* ref : ref_pair.second) { |
| 257 | os << reinterpret_cast<const void*>(ref->AsMirrorPtr()) << ","; |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 258 | } |
| 259 | os << "},"; |
| 260 | } |
| 261 | } |
| 262 | |
Mathieu Chartier | 407f702 | 2014-02-18 14:37:05 -0800 | [diff] [blame] | 263 | void ModUnionTableReferenceCache::UpdateAndMarkReferences(MarkHeapReferenceCallback* callback, |
Mathieu Chartier | 815873e | 2014-02-13 18:02:13 -0800 | [diff] [blame] | 264 | void* arg) { |
Mathieu Chartier | 4aeec17 | 2014-03-27 16:09:46 -0700 | [diff] [blame] | 265 | CardTable* card_table = heap_->GetCardTable(); |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 266 | |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 267 | std::vector<mirror::HeapReference<Object>*> cards_references; |
Mathieu Chartier | 11409ae | 2013-09-23 11:49:36 -0700 | [diff] [blame] | 268 | ModUnionReferenceVisitor add_visitor(this, &cards_references); |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 269 | |
Mathieu Chartier | 02e2511 | 2013-08-14 16:14:24 -0700 | [diff] [blame] | 270 | for (const auto& card : cleared_cards_) { |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 271 | // Clear and re-compute alloc space references associated with this card. |
| 272 | cards_references.clear(); |
| 273 | uintptr_t start = reinterpret_cast<uintptr_t>(card_table->AddrFromCard(card)); |
| 274 | uintptr_t end = start + CardTable::kCardSize; |
Mathieu Chartier | 4aeec17 | 2014-03-27 16:09:46 -0700 | [diff] [blame] | 275 | auto* space = heap_->FindContinuousSpaceFromObject(reinterpret_cast<Object*>(start), false); |
Mathieu Chartier | 02e2511 | 2013-08-14 16:14:24 -0700 | [diff] [blame] | 276 | DCHECK(space != nullptr); |
Mathieu Chartier | a8e8f9c | 2014-04-09 14:51:05 -0700 | [diff] [blame] | 277 | ContinuousSpaceBitmap* live_bitmap = space->GetLiveBitmap(); |
Mathieu Chartier | 11409ae | 2013-09-23 11:49:36 -0700 | [diff] [blame] | 278 | live_bitmap->VisitMarkedRange(start, end, add_visitor); |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 279 | |
| 280 | // Update the corresponding references for the card. |
Mathieu Chartier | 02e2511 | 2013-08-14 16:14:24 -0700 | [diff] [blame] | 281 | auto found = references_.find(card); |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 282 | if (found == references_.end()) { |
| 283 | if (cards_references.empty()) { |
| 284 | // No reason to add empty array. |
| 285 | continue; |
| 286 | } |
| 287 | references_.Put(card, cards_references); |
| 288 | } else { |
| 289 | found->second = cards_references; |
| 290 | } |
| 291 | } |
| 292 | cleared_cards_.clear(); |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 293 | size_t count = 0; |
Mathieu Chartier | 02e2511 | 2013-08-14 16:14:24 -0700 | [diff] [blame] | 294 | for (const auto& ref : references_) { |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 295 | for (mirror::HeapReference<Object>* obj_ptr : ref.second) { |
Mathieu Chartier | 407f702 | 2014-02-18 14:37:05 -0800 | [diff] [blame] | 296 | callback(obj_ptr, arg); |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 297 | } |
Mathieu Chartier | 11409ae | 2013-09-23 11:49:36 -0700 | [diff] [blame] | 298 | count += ref.second.size(); |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 299 | } |
| 300 | if (VLOG_IS_ON(heap)) { |
| 301 | VLOG(gc) << "Marked " << count << " references in mod union table"; |
| 302 | } |
| 303 | } |
| 304 | |
Mathieu Chartier | 11409ae | 2013-09-23 11:49:36 -0700 | [diff] [blame] | 305 | void ModUnionTableCardCache::ClearCards() { |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 306 | CardTable* card_table = GetHeap()->GetCardTable(); |
| 307 | ModUnionClearCardSetVisitor visitor(&cleared_cards_); |
| 308 | // Clear dirty cards in the this space and update the corresponding mod-union bits. |
Mathieu Chartier | 11409ae | 2013-09-23 11:49:36 -0700 | [diff] [blame] | 309 | card_table->ModifyCardsAtomic(space_->Begin(), space_->End(), AgeCardVisitor(), visitor); |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 310 | } |
| 311 | |
| 312 | // Mark all references to the alloc space(s). |
Mathieu Chartier | 407f702 | 2014-02-18 14:37:05 -0800 | [diff] [blame] | 313 | void ModUnionTableCardCache::UpdateAndMarkReferences(MarkHeapReferenceCallback* callback, |
| 314 | void* arg) { |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 315 | CardTable* card_table = heap_->GetCardTable(); |
Mathieu Chartier | 83c8ee0 | 2014-01-28 14:50:23 -0800 | [diff] [blame] | 316 | ModUnionScanImageRootVisitor scan_visitor(callback, arg); |
Mathieu Chartier | a8e8f9c | 2014-04-09 14:51:05 -0700 | [diff] [blame] | 317 | ContinuousSpaceBitmap* bitmap = space_->GetLiveBitmap(); |
Mathieu Chartier | 02e2511 | 2013-08-14 16:14:24 -0700 | [diff] [blame] | 318 | for (const byte* card_addr : cleared_cards_) { |
Mathieu Chartier | 11409ae | 2013-09-23 11:49:36 -0700 | [diff] [blame] | 319 | uintptr_t start = reinterpret_cast<uintptr_t>(card_table->AddrFromCard(card_addr)); |
| 320 | DCHECK(space_->HasAddress(reinterpret_cast<Object*>(start))); |
| 321 | bitmap->VisitMarkedRange(start, start + CardTable::kCardSize, scan_visitor); |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 322 | } |
| 323 | } |
| 324 | |
| 325 | void ModUnionTableCardCache::Dump(std::ostream& os) { |
| 326 | CardTable* card_table = heap_->GetCardTable(); |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 327 | os << "ModUnionTable dirty cards: ["; |
Mathieu Chartier | 02e2511 | 2013-08-14 16:14:24 -0700 | [diff] [blame] | 328 | for (const byte* card_addr : cleared_cards_) { |
| 329 | auto start = reinterpret_cast<uintptr_t>(card_table->AddrFromCard(card_addr)); |
| 330 | auto end = start + CardTable::kCardSize; |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 331 | os << reinterpret_cast<void*>(start) << "-" << reinterpret_cast<void*>(end) << "\n"; |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 332 | } |
| 333 | os << "]"; |
| 334 | } |
| 335 | |
| 336 | } // namespace accounting |
| 337 | } // namespace gc |
| 338 | } // namespace art |