semi_space.h revision b76cac637691c29daa9c44e493b5bc26346ed116 
1/*
2 * Copyright (C) 2013 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#ifndef ART_RUNTIME_GC_COLLECTOR_SEMI_SPACE_H_
18#define ART_RUNTIME_GC_COLLECTOR_SEMI_SPACE_H_
19
20#include <memory>
21
22#include "atomic.h"
23#include "base/macros.h"
24#include "base/mutex.h"
25#include "garbage_collector.h"
26#include "gc/accounting/heap_bitmap.h"
27#include "immune_region.h"
28#include "object_callbacks.h"
29#include "offsets.h"
30
31namespace art {
32
33class Thread;
34
35namespace mirror {
36  class Class;
37  class Object;
38}  // namespace mirror
39
40namespace gc {
41
42class Heap;
43
44namespace accounting {
45  template <typename T> class AtomicStack;
46  typedef AtomicStack<mirror::Object*> ObjectStack;
47}  // namespace accounting
48
49namespace space {
50  class ContinuousMemMapAllocSpace;
51  class ContinuousSpace;
52}  // namespace space
53
54namespace collector {
55
56class SemiSpace : public GarbageCollector {
57 public:
58  // If true, use remembered sets in the generational mode.
59  static constexpr bool kUseRememberedSet = true;
60
61  explicit SemiSpace(Heap* heap, bool generational = false, const std::string& name_prefix = "");
62
63  ~SemiSpace() {}
64
65  virtual void RunPhases() OVERRIDE NO_THREAD_SAFETY_ANALYSIS;
66  virtual void InitializePhase();
67  virtual void MarkingPhase() EXCLUSIVE_LOCKS_REQUIRED(Locks::mutator_lock_)
68      LOCKS_EXCLUDED(Locks::heap_bitmap_lock_);
69  virtual void ReclaimPhase() EXCLUSIVE_LOCKS_REQUIRED(Locks::mutator_lock_)
70      LOCKS_EXCLUDED(Locks::heap_bitmap_lock_);
71  virtual void FinishPhase() EXCLUSIVE_LOCKS_REQUIRED(Locks::mutator_lock_);
72  void MarkReachableObjects()
73      EXCLUSIVE_LOCKS_REQUIRED(Locks::mutator_lock_, Locks::heap_bitmap_lock_);
74  virtual GcType GetGcType() const OVERRIDE {
75    return kGcTypePartial;
76  }
77  virtual CollectorType GetCollectorType() const OVERRIDE {
78    return generational_ ? kCollectorTypeGSS : kCollectorTypeSS;
79  }
80
81  // Sets which space we will be copying objects to.
82  void SetToSpace(space::ContinuousMemMapAllocSpace* to_space);
83
84  // Set the space where we copy objects from.
85  void SetFromSpace(space::ContinuousMemMapAllocSpace* from_space);
86
87  // Set whether or not we swap the semi spaces in the heap. This needs to be done with mutators
88  // suspended.
89  void SetSwapSemiSpaces(bool swap_semi_spaces) {
90    swap_semi_spaces_ = swap_semi_spaces;
91  }
92
93  // Initializes internal structures.
94  void Init();
95
96  // Find the default mark bitmap.
97  void FindDefaultMarkBitmap();
98
99  // Returns the new address of the object.
100  template<bool kPoisonReferences>
101  void MarkObject(mirror::ObjectReference<kPoisonReferences, mirror::Object>* obj_ptr)
102      EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_);
103
104  void ScanObject(mirror::Object* obj)
105      EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_);
106
107  void VerifyNoFromSpaceReferences(mirror::Object* obj)
108      SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_);
109
110  // Marks the root set at the start of a garbage collection.
111  void MarkRoots()
112      EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_);
113
114  // Bind the live bits to the mark bits of bitmaps for spaces that are never collected, ie
115  // the image. Mark that portion of the heap as immune.
116  virtual void BindBitmaps() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
117      LOCKS_EXCLUDED(Locks::heap_bitmap_lock_);
118
119  void UnBindBitmaps()
120      EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
121
122  void ProcessReferences(Thread* self) EXCLUSIVE_LOCKS_REQUIRED(Locks::mutator_lock_)
123      EXCLUSIVE_LOCKS_REQUIRED(Locks::mutator_lock_);
124
125  // Sweeps unmarked objects to complete the garbage collection.
126  virtual void Sweep(bool swap_bitmaps) EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
127
128  // Sweeps unmarked objects to complete the garbage collection.
129  void SweepLargeObjects(bool swap_bitmaps) EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
130
131  void SweepSystemWeaks()
132      SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_);
133
134  static void MarkRootCallback(mirror::Object** root, void* arg, uint32_t /*tid*/,
135                               RootType /*root_type*/)
136      EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_);
137
138  static mirror::Object* MarkObjectCallback(mirror::Object* root, void* arg)
139      EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_);
140
141  static void MarkHeapReferenceCallback(mirror::HeapReference<mirror::Object>* obj_ptr, void* arg)
142      EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_);
143
144  static void ProcessMarkStackCallback(void* arg)
145      EXCLUSIVE_LOCKS_REQUIRED(Locks::mutator_lock_, Locks::heap_bitmap_lock_);
146
147  static void DelayReferenceReferentCallback(mirror::Class* klass, mirror::Reference* ref,
148                                             void* arg)
149      SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_);
150
151  virtual mirror::Object* MarkNonForwardedObject(mirror::Object* obj)
152      EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_);
153
154  // Schedules an unmarked object for reference processing.
155  void DelayReferenceReferent(mirror::Class* klass, mirror::Reference* reference)
156      SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_);
157
158 protected:
159  // Returns null if the object is not marked, otherwise returns the forwarding address (same as
160  // object for non movable things).
161  mirror::Object* GetMarkedForwardAddress(mirror::Object* object) const
162      EXCLUSIVE_LOCKS_REQUIRED(Locks::mutator_lock_)
163      SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
164
165  static bool HeapReferenceMarkedCallback(mirror::HeapReference<mirror::Object>* object, void* arg)
166      EXCLUSIVE_LOCKS_REQUIRED(Locks::mutator_lock_)
167      SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
168
169  static mirror::Object* MarkedForwardingAddressCallback(mirror::Object* object, void* arg)
170      EXCLUSIVE_LOCKS_REQUIRED(Locks::mutator_lock_)
171      SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
172
173  // Marks or unmarks a large object based on whether or not set is true. If set is true, then we
174  // mark, otherwise we unmark.
175  bool MarkLargeObject(const mirror::Object* obj)
176      EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_)
177      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
178
179  // Expand mark stack to 2x its current size.
180  void ResizeMarkStack(size_t new_size);
181
182  // Returns true if we should sweep the space.
183  virtual bool ShouldSweepSpace(space::ContinuousSpace* space) const;
184
185  // Push an object onto the mark stack.
186  void MarkStackPush(mirror::Object* obj);
187
188  void UpdateAndMarkModUnion()
189      EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_)
190      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
191
192  // Recursively blackens objects on the mark stack.
193  void ProcessMarkStack()
194      EXCLUSIVE_LOCKS_REQUIRED(Locks::mutator_lock_, Locks::heap_bitmap_lock_);
195
196  inline mirror::Object* GetForwardingAddressInFromSpace(mirror::Object* obj) const
197      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
198
199  // Revoke all the thread-local buffers.
200  void RevokeAllThreadLocalBuffers();
201
202  // Current space, we check this space first to avoid searching for the appropriate space for an
203  // object.
204  accounting::ObjectStack* mark_stack_;
205
206  // Immune region, every object inside the immune region is assumed to be marked.
207  ImmuneRegion immune_region_;
208
209  // If true, the large object space is immune.
210  bool is_large_object_space_immune_;
211
212  // Destination and source spaces (can be any type of ContinuousMemMapAllocSpace which either has
213  // a live bitmap or doesn't).
214  space::ContinuousMemMapAllocSpace* to_space_;
215  // Cached live bitmap as an optimization.
216  accounting::ContinuousSpaceBitmap* to_space_live_bitmap_;
217  space::ContinuousMemMapAllocSpace* from_space_;
218  // Cached mark bitmap as an optimization.
219  accounting::HeapBitmap* mark_bitmap_;
220
221  Thread* self_;
222
223  // When true, the generational mode (promotion and the bump pointer
224  // space only collection) is enabled. TODO: move these to a new file
225  // as a new garbage collector?
226  const bool generational_;
227
228  // Used for the generational mode. the end/top of the bump
229  // pointer space at the end of the last collection.
230  byte* last_gc_to_space_end_;
231
232  // Used for the generational mode. During a collection, keeps track
233  // of how many bytes of objects have been copied so far from the
234  // bump pointer space to the non-moving space.
235  uint64_t bytes_promoted_;
236
237  // Used for the generational mode. Keeps track of how many bytes of
238  // objects have been copied so far from the bump pointer space to
239  // the non-moving space, since the last whole heap collection.
240  uint64_t bytes_promoted_since_last_whole_heap_collection_;
241
242  // Used for the generational mode. Keeps track of how many bytes of
243  // large objects were allocated at the last whole heap collection.
244  uint64_t large_object_bytes_allocated_at_last_whole_heap_collection_;
245
246  // Used for generational mode. When true, we only collect the from_space_.
247  bool collect_from_space_only_;
248
249  // The space which we are promoting into, only used for GSS.
250  space::ContinuousMemMapAllocSpace* promo_dest_space_;
251
252  // The space which we copy to if the to_space_ is full.
253  space::ContinuousMemMapAllocSpace* fallback_space_;
254
255  // How many objects and bytes we moved, used so that we don't need to Get the size of the
256  // to_space_ when calculating how many objects and bytes we freed.
257  size_t bytes_moved_;
258  size_t objects_moved_;
259
260  // How many bytes we avoided dirtying.
261  size_t saved_bytes_;
262
263  // The name of the collector.
264  std::string collector_name_;
265
266  // Used for the generational mode. The default interval of the whole
267  // heap collection. If N, the whole heap collection occurs every N
268  // collections.
269  static constexpr int kDefaultWholeHeapCollectionInterval = 5;
270
271  // Whether or not we swap the semi spaces in the heap during the marking phase.
272  bool swap_semi_spaces_;
273
274 private:
275  friend class BitmapSetSlowPathVisitor;
276  DISALLOW_COPY_AND_ASSIGN(SemiSpace);
277};
278
279}  // namespace collector
280}  // namespace gc
281}  // namespace art
282
283#endif  // ART_RUNTIME_GC_COLLECTOR_SEMI_SPACE_H_
284