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