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