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_spaces.h"
29 #include "mirror/object_reference.h"
30 #include "object_callbacks.h"
31 #include "offsets.h"
32 
33 namespace art {
34 
35 class Thread;
36 
37 namespace mirror {
38   class Class;
39   class Object;
40 }  // namespace mirror
41 
42 namespace gc {
43 
44 class Heap;
45 
46 namespace accounting {
47   template <typename T> class AtomicStack;
48   typedef AtomicStack<mirror::Object> ObjectStack;
49 }  // namespace accounting
50 
51 namespace space {
52   class ContinuousMemMapAllocSpace;
53   class ContinuousSpace;
54 }  // namespace space
55 
56 namespace collector {
57 
58 class 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 
~SemiSpace()65   ~SemiSpace() {}
66 
67   virtual void RunPhases() OVERRIDE NO_THREAD_SAFETY_ANALYSIS;
68   virtual void InitializePhase();
69   virtual void MarkingPhase() REQUIRES(Locks::mutator_lock_)
70       REQUIRES(!Locks::heap_bitmap_lock_);
71   virtual void ReclaimPhase() REQUIRES(Locks::mutator_lock_)
72       REQUIRES(!Locks::heap_bitmap_lock_);
73   virtual void FinishPhase() REQUIRES(Locks::mutator_lock_);
74   void MarkReachableObjects()
75       REQUIRES(Locks::mutator_lock_, Locks::heap_bitmap_lock_);
GetGcType()76   virtual GcType GetGcType() const OVERRIDE {
77     return kGcTypePartial;
78   }
GetCollectorType()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.
SetSwapSemiSpaces(bool swap_semi_spaces)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       REQUIRES(Locks::heap_bitmap_lock_, Locks::mutator_lock_);
105 
106   template<bool kPoisonReferences>
107   void MarkObjectIfNotInToSpace(mirror::ObjectReference<kPoisonReferences, mirror::Object>* obj_ptr)
108       REQUIRES(Locks::heap_bitmap_lock_, Locks::mutator_lock_);
109 
110   virtual mirror::Object* MarkObject(mirror::Object* root) OVERRIDE
111       REQUIRES(Locks::heap_bitmap_lock_, Locks::mutator_lock_);
112 
113   virtual void MarkHeapReference(mirror::HeapReference<mirror::Object>* obj_ptr) OVERRIDE
114       REQUIRES(Locks::heap_bitmap_lock_, Locks::mutator_lock_);
115 
116   void ScanObject(mirror::Object* obj)
117       REQUIRES(Locks::heap_bitmap_lock_, Locks::mutator_lock_);
118 
119   void VerifyNoFromSpaceReferences(mirror::Object* obj)
120       SHARED_REQUIRES(Locks::heap_bitmap_lock_, Locks::mutator_lock_);
121 
122   // Marks the root set at the start of a garbage collection.
123   void MarkRoots()
124       REQUIRES(Locks::heap_bitmap_lock_, Locks::mutator_lock_);
125 
126   // Bind the live bits to the mark bits of bitmaps for spaces that are never collected, ie
127   // the image. Mark that portion of the heap as immune.
128   virtual void BindBitmaps() SHARED_REQUIRES(Locks::mutator_lock_)
129       REQUIRES(!Locks::heap_bitmap_lock_);
130 
131   void UnBindBitmaps()
132       REQUIRES(Locks::heap_bitmap_lock_);
133 
134   void ProcessReferences(Thread* self) REQUIRES(Locks::mutator_lock_)
135       REQUIRES(Locks::mutator_lock_);
136 
137   // Sweeps unmarked objects to complete the garbage collection.
138   virtual void Sweep(bool swap_bitmaps)
139       REQUIRES(Locks::heap_bitmap_lock_)
140       SHARED_REQUIRES(Locks::mutator_lock_);
141 
142   // Sweeps unmarked objects to complete the garbage collection.
143   void SweepLargeObjects(bool swap_bitmaps) REQUIRES(Locks::heap_bitmap_lock_);
144 
145   void SweepSystemWeaks()
146       SHARED_REQUIRES(Locks::heap_bitmap_lock_, Locks::mutator_lock_);
147 
148   virtual void VisitRoots(mirror::Object*** roots, size_t count, const RootInfo& info) OVERRIDE
149       REQUIRES(Locks::mutator_lock_, Locks::heap_bitmap_lock_);
150 
151   virtual void VisitRoots(mirror::CompressedReference<mirror::Object>** roots, size_t count,
152                           const RootInfo& info) OVERRIDE
153       REQUIRES(Locks::mutator_lock_, Locks::heap_bitmap_lock_);
154 
155   virtual mirror::Object* MarkNonForwardedObject(mirror::Object* obj)
156       REQUIRES(Locks::heap_bitmap_lock_, Locks::mutator_lock_);
157 
158   // Schedules an unmarked object for reference processing.
159   void DelayReferenceReferent(mirror::Class* klass, mirror::Reference* reference)
160       SHARED_REQUIRES(Locks::heap_bitmap_lock_, Locks::mutator_lock_);
161 
162  protected:
163   // Returns null if the object is not marked, otherwise returns the forwarding address (same as
164   // object for non movable things).
165   virtual mirror::Object* IsMarked(mirror::Object* object) OVERRIDE
166       REQUIRES(Locks::mutator_lock_)
167       SHARED_REQUIRES(Locks::heap_bitmap_lock_);
168 
169   virtual bool IsMarkedHeapReference(mirror::HeapReference<mirror::Object>* object) OVERRIDE
170       REQUIRES(Locks::mutator_lock_)
171       SHARED_REQUIRES(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       REQUIRES(Locks::heap_bitmap_lock_)
177       SHARED_REQUIRES(Locks::mutator_lock_);
178 
179   // Expand mark stack to 2x its current size.
180   void ResizeMarkStack(size_t new_size) SHARED_REQUIRES(Locks::mutator_lock_);
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) SHARED_REQUIRES(Locks::mutator_lock_);
187 
188   void UpdateAndMarkModUnion()
189       REQUIRES(Locks::heap_bitmap_lock_)
190       SHARED_REQUIRES(Locks::mutator_lock_);
191 
192   // Recursively blackens objects on the mark stack.
193   void ProcessMarkStack()
194       REQUIRES(Locks::mutator_lock_, Locks::heap_bitmap_lock_);
195 
196   inline mirror::Object* GetForwardingAddressInFromSpace(mirror::Object* obj) const
197       SHARED_REQUIRES(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   // Every object inside the immune spaces is assumed to be marked.
207   ImmuneSpaces immune_spaces_;
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   uint8_t* 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_IMPLICIT_CONSTRUCTORS(SemiSpace);
277 };
278 
279 }  // namespace collector
280 }  // namespace gc
281 }  // namespace art
282 
283 #endif  // ART_RUNTIME_GC_COLLECTOR_SEMI_SPACE_H_
284