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