1 /* 2 * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #include "precompiled.hpp" 26 #include "compiler/compileBroker.hpp" 27 #include "gc/serial/markSweep.inline.hpp" 28 #include "gc/shared/collectedHeap.inline.hpp" 29 #include "gc/shared/gcTimer.hpp" 30 #include "gc/shared/gcTrace.hpp" 31 #include "gc/shared/specialized_oop_closures.hpp" 32 #include "memory/iterator.inline.hpp" 33 #include "oops/instanceClassLoaderKlass.inline.hpp" 34 #include "oops/instanceKlass.inline.hpp" 35 #include "oops/instanceMirrorKlass.inline.hpp" 36 #include "oops/instanceRefKlass.inline.hpp" 37 #include "oops/methodData.hpp" 38 #include "oops/objArrayKlass.inline.hpp" 39 #include "oops/oop.inline.hpp" 40 #include "oops/typeArrayOop.inline.hpp" 41 #include "utilities/macros.hpp" 42 #include "utilities/stack.inline.hpp" 43 #if INCLUDE_ALL_GCS 44 #include "gc/g1/g1StringDedup.hpp" 45 #endif // INCLUDE_ALL_GCS 46 47 uint MarkSweep::_total_invocations = 0; 48 49 Stack<oop, mtGC> MarkSweep::_marking_stack; 50 Stack<ObjArrayTask, mtGC> MarkSweep::_objarray_stack; 51 52 Stack<oop, mtGC> MarkSweep::_preserved_oop_stack; 53 Stack<markOop, mtGC> MarkSweep::_preserved_mark_stack; 54 size_t MarkSweep::_preserved_count = 0; 55 size_t MarkSweep::_preserved_count_max = 0; 56 PreservedMark* MarkSweep::_preserved_marks = NULL; 57 ReferenceProcessor* MarkSweep::_ref_processor = NULL; 58 STWGCTimer* MarkSweep::_gc_timer = NULL; 59 SerialOldTracer* MarkSweep::_gc_tracer = NULL; 60 61 MarkSweep::FollowRootClosure MarkSweep::follow_root_closure; 62 63 MarkAndPushClosure MarkSweep::mark_and_push_closure; 64 CLDToOopClosure MarkSweep::follow_cld_closure(&mark_and_push_closure); 65 CLDToOopClosure MarkSweep::adjust_cld_closure(&adjust_pointer_closure); 66 67 inline void MarkSweep::mark_object(oop obj) { 68 #if INCLUDE_ALL_GCS 69 if (G1StringDedup::is_enabled()) { 70 // We must enqueue the object before it is marked 71 // as we otherwise can't read the object's age. 72 G1StringDedup::enqueue_from_mark(obj); 73 } 74 #endif 75 // some marks may contain information we need to preserve so we store them away 76 // and overwrite the mark. We'll restore it at the end of markSweep. 77 markOop mark = obj->mark(); 78 obj->set_mark(markOopDesc::prototype()->set_marked()); 79 80 if (mark->must_be_preserved(obj)) { 81 preserve_mark(obj, mark); 82 } 83 } 84 85 template <class T> inline void MarkSweep::mark_and_push(T* p) { 86 T heap_oop = oopDesc::load_heap_oop(p); 87 if (!oopDesc::is_null(heap_oop)) { 88 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); 89 if (!obj->mark()->is_marked() && 90 !is_archive_object(obj)) { 91 mark_object(obj); 92 _marking_stack.push(obj); 93 } 94 } 95 } 96 97 inline void MarkSweep::follow_klass(Klass* klass) { 98 oop op = klass->klass_holder(); 99 MarkSweep::mark_and_push(&op); 100 } 101 102 inline void MarkSweep::follow_cld(ClassLoaderData* cld) { 103 MarkSweep::follow_cld_closure.do_cld(cld); 104 } 105 106 template <typename T> 107 inline void MarkAndPushClosure::do_oop_nv(T* p) { MarkSweep::mark_and_push(p); } 108 void MarkAndPushClosure::do_oop(oop* p) { do_oop_nv(p); } 109 void MarkAndPushClosure::do_oop(narrowOop* p) { do_oop_nv(p); } 110 inline bool MarkAndPushClosure::do_metadata_nv() { return true; } 111 bool MarkAndPushClosure::do_metadata() { return do_metadata_nv(); } 112 inline void MarkAndPushClosure::do_klass_nv(Klass* k) { MarkSweep::follow_klass(k); } 113 void MarkAndPushClosure::do_klass(Klass* k) { do_klass_nv(k); } 114 inline void MarkAndPushClosure::do_cld_nv(ClassLoaderData* cld) { MarkSweep::follow_cld(cld); } 115 void MarkAndPushClosure::do_cld(ClassLoaderData* cld) { do_cld_nv(cld); } 116 117 template <class T> inline void MarkSweep::KeepAliveClosure::do_oop_work(T* p) { 118 mark_and_push(p); 119 } 120 121 void MarkSweep::push_objarray(oop obj, size_t index) { 122 ObjArrayTask task(obj, index); 123 assert(task.is_valid(), "bad ObjArrayTask"); 124 _objarray_stack.push(task); 125 } 126 127 inline void MarkSweep::follow_array(objArrayOop array) { 128 MarkSweep::follow_klass(array->klass()); 129 // Don't push empty arrays to avoid unnecessary work. 130 if (array->length() > 0) { 131 MarkSweep::push_objarray(array, 0); 132 } 133 } 134 135 inline void MarkSweep::follow_object(oop obj) { 136 assert(obj->is_gc_marked(), "should be marked"); 137 if (obj->is_objArray()) { 138 // Handle object arrays explicitly to allow them to 139 // be split into chunks if needed. 140 MarkSweep::follow_array((objArrayOop)obj); 141 } else { 142 obj->oop_iterate(&mark_and_push_closure); 143 } 144 } 145 146 void MarkSweep::follow_array_chunk(objArrayOop array, int index) { 147 const int len = array->length(); 148 const int beg_index = index; 149 assert(beg_index < len || len == 0, "index too large"); 150 151 const int stride = MIN2(len - beg_index, (int) ObjArrayMarkingStride); 152 const int end_index = beg_index + stride; 153 154 array->oop_iterate_range(&mark_and_push_closure, beg_index, end_index); 155 156 if (end_index < len) { 157 MarkSweep::push_objarray(array, end_index); // Push the continuation. 158 } 159 } 160 161 void MarkSweep::follow_stack() { 162 do { 163 while (!_marking_stack.is_empty()) { 164 oop obj = _marking_stack.pop(); 165 assert (obj->is_gc_marked(), "p must be marked"); 166 follow_object(obj); 167 } 168 // Process ObjArrays one at a time to avoid marking stack bloat. 169 if (!_objarray_stack.is_empty()) { 170 ObjArrayTask task = _objarray_stack.pop(); 171 follow_array_chunk(objArrayOop(task.obj()), task.index()); 172 } 173 } while (!_marking_stack.is_empty() || !_objarray_stack.is_empty()); 174 } 175 176 MarkSweep::FollowStackClosure MarkSweep::follow_stack_closure; 177 178 void MarkSweep::FollowStackClosure::do_void() { follow_stack(); } 179 180 template <class T> inline void MarkSweep::follow_root(T* p) { 181 assert(!Universe::heap()->is_in_reserved(p), 182 "roots shouldn't be things within the heap"); 183 T heap_oop = oopDesc::load_heap_oop(p); 184 if (!oopDesc::is_null(heap_oop)) { 185 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); 186 if (!obj->mark()->is_marked() && 187 !is_archive_object(obj)) { 188 mark_object(obj); 189 follow_object(obj); 190 } 191 } 192 follow_stack(); 193 } 194 195 void MarkSweep::FollowRootClosure::do_oop(oop* p) { follow_root(p); } 196 void MarkSweep::FollowRootClosure::do_oop(narrowOop* p) { follow_root(p); } 197 198 void PreservedMark::adjust_pointer() { 199 MarkSweep::adjust_pointer(&_obj); 200 } 201 202 void PreservedMark::restore() { 203 _obj->set_mark(_mark); 204 } 205 206 // We preserve the mark which should be replaced at the end and the location 207 // that it will go. Note that the object that this markOop belongs to isn't 208 // currently at that address but it will be after phase4 209 void MarkSweep::preserve_mark(oop obj, markOop mark) { 210 // We try to store preserved marks in the to space of the new generation since 211 // this is storage which should be available. Most of the time this should be 212 // sufficient space for the marks we need to preserve but if it isn't we fall 213 // back to using Stacks to keep track of the overflow. 214 if (_preserved_count < _preserved_count_max) { 215 _preserved_marks[_preserved_count++].init(obj, mark); 216 } else { 217 _preserved_mark_stack.push(mark); 218 _preserved_oop_stack.push(obj); 219 } 220 } 221 222 void MarkSweep::set_ref_processor(ReferenceProcessor* rp) { 223 _ref_processor = rp; 224 mark_and_push_closure.set_ref_processor(_ref_processor); 225 } 226 227 MarkSweep::AdjustPointerClosure MarkSweep::adjust_pointer_closure; 228 229 template <typename T> 230 void MarkSweep::AdjustPointerClosure::do_oop_nv(T* p) { adjust_pointer(p); } 231 void MarkSweep::AdjustPointerClosure::do_oop(oop* p) { do_oop_nv(p); } 232 void MarkSweep::AdjustPointerClosure::do_oop(narrowOop* p) { do_oop_nv(p); } 233 234 void MarkSweep::adjust_marks() { 235 assert( _preserved_oop_stack.size() == _preserved_mark_stack.size(), 236 "inconsistent preserved oop stacks"); 237 238 // adjust the oops we saved earlier 239 for (size_t i = 0; i < _preserved_count; i++) { 240 _preserved_marks[i].adjust_pointer(); 241 } 242 243 // deal with the overflow stack 244 StackIterator<oop, mtGC> iter(_preserved_oop_stack); 245 while (!iter.is_empty()) { 246 oop* p = iter.next_addr(); 247 adjust_pointer(p); 248 } 249 } 250 251 void MarkSweep::restore_marks() { 252 assert(_preserved_oop_stack.size() == _preserved_mark_stack.size(), 253 "inconsistent preserved oop stacks"); 254 log_trace(gc)("Restoring " SIZE_FORMAT " marks", _preserved_count + _preserved_oop_stack.size()); 255 256 // restore the marks we saved earlier 257 for (size_t i = 0; i < _preserved_count; i++) { 258 _preserved_marks[i].restore(); 259 } 260 261 // deal with the overflow 262 while (!_preserved_oop_stack.is_empty()) { 263 oop obj = _preserved_oop_stack.pop(); 264 markOop mark = _preserved_mark_stack.pop(); 265 obj->set_mark(mark); 266 } 267 } 268 269 MarkSweep::IsAliveClosure MarkSweep::is_alive; 270 271 bool MarkSweep::IsAliveClosure::do_object_b(oop p) { return p->is_gc_marked() || is_archive_object(p); } 272 273 MarkSweep::KeepAliveClosure MarkSweep::keep_alive; 274 275 void MarkSweep::KeepAliveClosure::do_oop(oop* p) { MarkSweep::KeepAliveClosure::do_oop_work(p); } 276 void MarkSweep::KeepAliveClosure::do_oop(narrowOop* p) { MarkSweep::KeepAliveClosure::do_oop_work(p); } 277 278 void marksweep_init() { 279 MarkSweep::_gc_timer = new (ResourceObj::C_HEAP, mtGC) STWGCTimer(); 280 MarkSweep::_gc_tracer = new (ResourceObj::C_HEAP, mtGC) SerialOldTracer(); 281 } 282 283 int InstanceKlass::oop_ms_adjust_pointers(oop obj) { 284 int size = size_helper(); 285 oop_oop_iterate_oop_maps<true>(obj, &MarkSweep::adjust_pointer_closure); 286 return size; 287 } 288 289 int InstanceMirrorKlass::oop_ms_adjust_pointers(oop obj) { 290 int size = oop_size(obj); 291 InstanceKlass::oop_ms_adjust_pointers(obj); 292 293 oop_oop_iterate_statics<true>(obj, &MarkSweep::adjust_pointer_closure); 294 return size; 295 } 296 297 int InstanceClassLoaderKlass::oop_ms_adjust_pointers(oop obj) { 298 return InstanceKlass::oop_ms_adjust_pointers(obj); 299 } 300 301 #ifdef ASSERT 302 template <class T> static void trace_reference_gc(const char *s, oop obj, 303 T* referent_addr, 304 T* next_addr, 305 T* discovered_addr) { 306 log_develop_trace(gc, ref)("%s obj " PTR_FORMAT, s, p2i(obj)); 307 log_develop_trace(gc, ref)(" referent_addr/* " PTR_FORMAT " / " PTR_FORMAT, 308 p2i(referent_addr), p2i(referent_addr ? (address)oopDesc::load_decode_heap_oop(referent_addr) : NULL)); 309 log_develop_trace(gc, ref)(" next_addr/* " PTR_FORMAT " / " PTR_FORMAT, 310 p2i(next_addr), p2i(next_addr ? (address)oopDesc::load_decode_heap_oop(next_addr) : NULL)); 311 log_develop_trace(gc, ref)(" discovered_addr/* " PTR_FORMAT " / " PTR_FORMAT, 312 p2i(discovered_addr), p2i(discovered_addr ? (address)oopDesc::load_decode_heap_oop(discovered_addr) : NULL)); 313 } 314 #endif 315 316 template <class T> void static adjust_object_specialized(oop obj) { 317 T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj); 318 MarkSweep::adjust_pointer(referent_addr); 319 T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj); 320 MarkSweep::adjust_pointer(next_addr); 321 T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj); 322 MarkSweep::adjust_pointer(discovered_addr); 323 debug_only(trace_reference_gc("InstanceRefKlass::oop_ms_adjust_pointers", obj, 324 referent_addr, next_addr, discovered_addr);) 325 } 326 327 int InstanceRefKlass::oop_ms_adjust_pointers(oop obj) { 328 int size = size_helper(); 329 InstanceKlass::oop_ms_adjust_pointers(obj); 330 331 if (UseCompressedOops) { 332 adjust_object_specialized<narrowOop>(obj); 333 } else { 334 adjust_object_specialized<oop>(obj); 335 } 336 return size; 337 } 338 339 int ObjArrayKlass::oop_ms_adjust_pointers(oop obj) { 340 assert(obj->is_objArray(), "obj must be obj array"); 341 objArrayOop a = objArrayOop(obj); 342 // Get size before changing pointers. 343 // Don't call size() or oop_size() since that is a virtual call. 344 int size = a->object_size(); 345 oop_oop_iterate_elements<true>(a, &MarkSweep::adjust_pointer_closure); 346 return size; 347 } 348 349 int TypeArrayKlass::oop_ms_adjust_pointers(oop obj) { 350 assert(obj->is_typeArray(), "must be a type array"); 351 typeArrayOop t = typeArrayOop(obj); 352 // Performance tweak: We skip iterating over the klass pointer since we 353 // know that Universe::TypeArrayKlass never moves. 354 return t->object_size(); 355 } 356 357 // Generate MS specialized oop_oop_iterate functions. 358 SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_MS(ALL_KLASS_OOP_OOP_ITERATE_DEFN)