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/object-inl.h"
30 #include "mirror/class-inl.h"
31 #include "mirror/object_array-inl.h"
32 #include "space_bitmap-inl.h"
33 #include "thread.h"
34
35 namespace art {
36 namespace gc {
37 namespace accounting {
38
39 class RememberedSetCardVisitor {
40 public:
RememberedSetCardVisitor(RememberedSet::CardSet * const dirty_cards)41 explicit RememberedSetCardVisitor(RememberedSet::CardSet* const dirty_cards)
42 : dirty_cards_(dirty_cards) {}
43
operator ()(uint8_t * card,uint8_t expected_value,uint8_t new_value ATTRIBUTE_UNUSED) const44 void operator()(uint8_t* card, uint8_t expected_value, uint8_t new_value ATTRIBUTE_UNUSED) const {
45 if (expected_value == CardTable::kCardDirty) {
46 dirty_cards_->insert(card);
47 }
48 }
49
50 private:
51 RememberedSet::CardSet* const dirty_cards_;
52 };
53
ClearCards()54 void RememberedSet::ClearCards() {
55 CardTable* card_table = GetHeap()->GetCardTable();
56 RememberedSetCardVisitor card_visitor(&dirty_cards_);
57 // Clear dirty cards in the space and insert them into the dirty card set.
58 card_table->ModifyCardsAtomic(space_->Begin(), space_->End(), AgeCardVisitor(), card_visitor);
59 }
60
61 class RememberedSetReferenceVisitor {
62 public:
RememberedSetReferenceVisitor(space::ContinuousSpace * target_space,bool * const contains_reference_to_target_space,collector::GarbageCollector * collector)63 RememberedSetReferenceVisitor(space::ContinuousSpace* target_space,
64 bool* const contains_reference_to_target_space,
65 collector::GarbageCollector* collector)
66 : collector_(collector), target_space_(target_space),
67 contains_reference_to_target_space_(contains_reference_to_target_space) {}
68
operator ()(mirror::Object * obj,MemberOffset offset,bool is_static ATTRIBUTE_UNUSED) const69 void operator()(mirror::Object* obj, MemberOffset offset, bool is_static ATTRIBUTE_UNUSED) const
70 SHARED_REQUIRES(Locks::mutator_lock_) {
71 DCHECK(obj != nullptr);
72 mirror::HeapReference<mirror::Object>* ref_ptr = obj->GetFieldObjectReferenceAddr(offset);
73 if (target_space_->HasAddress(ref_ptr->AsMirrorPtr())) {
74 *contains_reference_to_target_space_ = true;
75 collector_->MarkHeapReference(ref_ptr);
76 DCHECK(!target_space_->HasAddress(ref_ptr->AsMirrorPtr()));
77 }
78 }
79
operator ()(mirror::Class * klass,mirror::Reference * ref) const80 void operator()(mirror::Class* klass, mirror::Reference* ref) const
81 SHARED_REQUIRES(Locks::mutator_lock_) REQUIRES(Locks::heap_bitmap_lock_) {
82 if (target_space_->HasAddress(ref->GetReferent())) {
83 *contains_reference_to_target_space_ = true;
84 collector_->DelayReferenceReferent(klass, ref);
85 }
86 }
87
VisitRootIfNonNull(mirror::CompressedReference<mirror::Object> * root) const88 void VisitRootIfNonNull(mirror::CompressedReference<mirror::Object>* root) const
89 SHARED_REQUIRES(Locks::mutator_lock_) {
90 if (!root->IsNull()) {
91 VisitRoot(root);
92 }
93 }
94
VisitRoot(mirror::CompressedReference<mirror::Object> * root) const95 void VisitRoot(mirror::CompressedReference<mirror::Object>* root) const
96 SHARED_REQUIRES(Locks::mutator_lock_) {
97 if (target_space_->HasAddress(root->AsMirrorPtr())) {
98 *contains_reference_to_target_space_ = true;
99 root->Assign(collector_->MarkObject(root->AsMirrorPtr()));
100 DCHECK(!target_space_->HasAddress(root->AsMirrorPtr()));
101 }
102 }
103
104 private:
105 collector::GarbageCollector* const collector_;
106 space::ContinuousSpace* const target_space_;
107 bool* const contains_reference_to_target_space_;
108 };
109
110 class RememberedSetObjectVisitor {
111 public:
RememberedSetObjectVisitor(space::ContinuousSpace * target_space,bool * const contains_reference_to_target_space,collector::GarbageCollector * collector)112 RememberedSetObjectVisitor(space::ContinuousSpace* target_space,
113 bool* const contains_reference_to_target_space,
114 collector::GarbageCollector* collector)
115 : collector_(collector), target_space_(target_space),
116 contains_reference_to_target_space_(contains_reference_to_target_space) {}
117
operator ()(mirror::Object * obj) const118 void operator()(mirror::Object* obj) const REQUIRES(Locks::heap_bitmap_lock_)
119 SHARED_REQUIRES(Locks::mutator_lock_) {
120 RememberedSetReferenceVisitor visitor(target_space_, contains_reference_to_target_space_,
121 collector_);
122 obj->VisitReferences(visitor, visitor);
123 }
124
125 private:
126 collector::GarbageCollector* const collector_;
127 space::ContinuousSpace* const target_space_;
128 bool* const contains_reference_to_target_space_;
129 };
130
UpdateAndMarkReferences(space::ContinuousSpace * target_space,collector::GarbageCollector * collector)131 void RememberedSet::UpdateAndMarkReferences(space::ContinuousSpace* target_space,
132 collector::GarbageCollector* collector) {
133 CardTable* card_table = heap_->GetCardTable();
134 bool contains_reference_to_target_space = false;
135 RememberedSetObjectVisitor obj_visitor(target_space, &contains_reference_to_target_space,
136 collector);
137 ContinuousSpaceBitmap* bitmap = space_->GetLiveBitmap();
138 CardSet remove_card_set;
139 for (uint8_t* const card_addr : dirty_cards_) {
140 contains_reference_to_target_space = false;
141 uintptr_t start = reinterpret_cast<uintptr_t>(card_table->AddrFromCard(card_addr));
142 DCHECK(space_->HasAddress(reinterpret_cast<mirror::Object*>(start)));
143 bitmap->VisitMarkedRange(start, start + CardTable::kCardSize, obj_visitor);
144 if (!contains_reference_to_target_space) {
145 // It was in the dirty card set, but it didn't actually contain
146 // a reference to the target space. So, remove it from the dirty
147 // card set so we won't have to scan it again (unless it gets
148 // dirty again.)
149 remove_card_set.insert(card_addr);
150 }
151 }
152
153 // Remove the cards that didn't contain a reference to the target
154 // space from the dirty card set.
155 for (uint8_t* const card_addr : remove_card_set) {
156 DCHECK(dirty_cards_.find(card_addr) != dirty_cards_.end());
157 dirty_cards_.erase(card_addr);
158 }
159 }
160
Dump(std::ostream & os)161 void RememberedSet::Dump(std::ostream& os) {
162 CardTable* card_table = heap_->GetCardTable();
163 os << "RememberedSet dirty cards: [";
164 for (const uint8_t* card_addr : dirty_cards_) {
165 auto start = reinterpret_cast<uintptr_t>(card_table->AddrFromCard(card_addr));
166 auto end = start + CardTable::kCardSize;
167 os << reinterpret_cast<void*>(start) << "-" << reinterpret_cast<void*>(end) << "\n";
168 }
169 os << "]";
170 }
171
AssertAllDirtyCardsAreWithinSpace() const172 void RememberedSet::AssertAllDirtyCardsAreWithinSpace() const {
173 CardTable* card_table = heap_->GetCardTable();
174 for (const uint8_t* card_addr : dirty_cards_) {
175 auto start = reinterpret_cast<uint8_t*>(card_table->AddrFromCard(card_addr));
176 auto end = start + CardTable::kCardSize;
177 DCHECK_LE(space_->Begin(), start);
178 DCHECK_LE(end, space_->Limit());
179 }
180 }
181
182 } // namespace accounting
183 } // namespace gc
184 } // namespace art
185