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 STWGCTimer* MarkSweep::_gc_timer = NULL; 50 SerialOldTracer* MarkSweep::_gc_tracer = NULL; 51 52 MarkSweep::MarkSweep() : 53 _marking_stack(), 54 _objarray_stack(), 55 _preserved_mark_stack(), 56 _preserved_oop_stack(), 57 _preserved_count(0), 58 _preserved_count_max(0), 59 _preserved_marks(NULL), 60 _ref_processor(NULL), 61 keep_alive(this), 62 is_alive(this), 63 follow_root_closure(this), 64 mark_and_push_closure(this), 65 follow_stack_closure(this), 66 follow_cld_closure(&mark_and_push_closure), 67 adjust_pointer_closure(), 68 adjust_cld_closure(&adjust_pointer_closure) 69 { 70 } 71 72 MarkSweep::~MarkSweep() 73 { 74 } 75 76 inline void MarkSweep::mark_object(oop obj) { 77 #if INCLUDE_ALL_GCS 78 if (G1StringDedup::is_enabled()) { 79 // We must enqueue the object before it is marked 80 // as we otherwise can't read the object's age. 81 G1StringDedup::enqueue_from_mark(obj); 82 } 83 #endif 84 // some marks may contain information we need to preserve so we store them away 85 // and overwrite the mark. We'll restore it at the end of markSweep. 86 markOop mark = obj->mark(); 87 obj->set_mark(markOopDesc::prototype()->set_marked()); 88 89 if (mark->must_be_preserved(obj)) { 90 preserve_mark(obj, mark); 91 } 92 } 93 94 template <class T> inline void MarkSweep::mark_and_push(T* p) { 95 T heap_oop = oopDesc::load_heap_oop(p); 96 if (!oopDesc::is_null(heap_oop)) { 97 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); 98 if (!obj->mark()->is_marked() && 99 !is_archive_object(obj)) { 100 mark_object(obj); 101 _marking_stack.push(obj); 102 } 103 } 104 } 105 106 inline void MarkSweep::follow_klass(Klass* klass) { 107 oop op = klass->klass_holder(); 108 mark_and_push(&op); 109 } 110 111 inline void MarkSweep::follow_cld(ClassLoaderData* cld) { 112 follow_cld_closure.do_cld(cld); 113 } 114 115 template <typename T> 116 inline void MarkAndPushClosure::do_oop_nv(T* p) { _ms->mark_and_push(p); } 117 void MarkAndPushClosure::do_oop(oop* p) { do_oop_nv(p); } 118 void MarkAndPushClosure::do_oop(narrowOop* p) { do_oop_nv(p); } 119 inline bool MarkAndPushClosure::do_metadata_nv() { return true; } 120 bool MarkAndPushClosure::do_metadata() { return do_metadata_nv(); } 121 inline void MarkAndPushClosure::do_klass_nv(Klass* k) { _ms->follow_klass(k); } 122 void MarkAndPushClosure::do_klass(Klass* k) { do_klass_nv(k); } 123 inline void MarkAndPushClosure::do_cld_nv(ClassLoaderData* cld) { _ms->follow_cld(cld); } 124 void MarkAndPushClosure::do_cld(ClassLoaderData* cld) { do_cld_nv(cld); } 125 126 template <class T> inline void MarkSweep::KeepAliveClosure::do_oop_work(T* p) { 127 _ms->mark_and_push(p); 128 } 129 130 void MarkSweep::push_objarray(oop obj, size_t index) { 131 ObjArrayTask task(obj, index); 132 assert(task.is_valid(), "bad ObjArrayTask"); 133 _objarray_stack.push(task); 134 } 135 136 inline void MarkSweep::follow_array(objArrayOop array) { 137 follow_klass(array->klass()); 138 // Don't push empty arrays to avoid unnecessary work. 139 if (array->length() > 0) { 140 push_objarray(array, 0); 141 } 142 } 143 144 inline void MarkSweep::follow_object(oop obj) { 145 assert(obj->is_gc_marked(), "should be marked"); 146 if (obj->is_objArray()) { 147 // Handle object arrays explicitly to allow them to 148 // be split into chunks if needed. 149 follow_array((objArrayOop)obj); 150 } else { 151 obj->oop_iterate(&mark_and_push_closure); 152 } 153 } 154 155 void MarkSweep::follow_array_chunk(objArrayOop array, int index) { 156 const int len = array->length(); 157 const int beg_index = index; 158 assert(beg_index < len || len == 0, "index too large"); 159 160 const int stride = MIN2(len - beg_index, (int) ObjArrayMarkingStride); 161 const int end_index = beg_index + stride; 162 163 array->oop_iterate_range(&mark_and_push_closure, beg_index, end_index); 164 165 if (end_index < len) { 166 push_objarray(array, end_index); // Push the continuation. 167 } 168 } 169 170 void MarkSweep::follow_stack() { 171 do { 172 while (!_marking_stack.is_empty()) { 173 oop obj = _marking_stack.pop(); 174 assert (obj->is_gc_marked(), "p must be marked"); 175 follow_object(obj); 176 } 177 // Process ObjArrays one at a time to avoid marking stack bloat. 178 if (!_objarray_stack.is_empty()) { 179 ObjArrayTask task = _objarray_stack.pop(); 180 follow_array_chunk(objArrayOop(task.obj()), task.index()); 181 } 182 } while (!_marking_stack.is_empty() || !_objarray_stack.is_empty()); 183 } 184 185 void MarkSweep::FollowStackClosure::do_void() { _ms->follow_stack(); } 186 187 template <class T> inline void MarkSweep::follow_root(T* p) { 188 assert(!Universe::heap()->is_in_reserved(p), 189 "roots shouldn't be things within the heap"); 190 T heap_oop = oopDesc::load_heap_oop(p); 191 if (!oopDesc::is_null(heap_oop)) { 192 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); 193 if (!obj->mark()->is_marked() && 194 !is_archive_object(obj)) { 195 mark_object(obj); 196 follow_object(obj); 197 } 198 } 199 follow_stack(); 200 } 201 202 void MarkSweep::FollowRootClosure::do_oop(oop* p) { _ms->follow_root(p); } 203 void MarkSweep::FollowRootClosure::do_oop(narrowOop* p) { _ms->follow_root(p); } 204 205 void PreservedMark::adjust_pointer() { 206 MarkSweep::adjust_pointer(&_obj); 207 } 208 209 void PreservedMark::restore() { 210 _obj->set_mark(_mark); 211 } 212 213 // We preserve the mark which should be replaced at the end and the location 214 // that it will go. Note that the object that this markOop belongs to isn't 215 // currently at that address but it will be after phase4 216 void MarkSweep::preserve_mark(oop obj, markOop mark) { 217 // We try to store preserved marks in the to space of the new generation since 218 // this is storage which should be available. Most of the time this should be 219 // sufficient space for the marks we need to preserve but if it isn't we fall 220 // back to using Stacks to keep track of the overflow. 221 if (_preserved_count < _preserved_count_max) { 222 _preserved_marks[_preserved_count++].init(obj, mark); 223 } else { 224 _preserved_mark_stack.push(mark); 225 _preserved_oop_stack.push(obj); 226 } 227 } 228 229 void MarkSweep::set_ref_processor(ReferenceProcessor* rp) { 230 _ref_processor = rp; 231 mark_and_push_closure.set_ref_processor(_ref_processor); 232 } 233 234 template <typename T> 235 void MarkSweep::AdjustPointerClosure::do_oop_nv(T* p) { adjust_pointer(p); } 236 void MarkSweep::AdjustPointerClosure::do_oop(oop* p) { do_oop_nv(p); } 237 void MarkSweep::AdjustPointerClosure::do_oop(narrowOop* p) { do_oop_nv(p); } 238 239 void MarkSweep::adjust_marks() { 240 assert( _preserved_oop_stack.size() == _preserved_mark_stack.size(), 241 "inconsistent preserved oop stacks"); 242 243 // adjust the oops we saved earlier 244 for (size_t i = 0; i < _preserved_count; i++) { 245 _preserved_marks[i].adjust_pointer(); 246 } 247 248 // deal with the overflow stack 249 StackIterator<oop, mtGC> iter(_preserved_oop_stack); 250 while (!iter.is_empty()) { 251 oop* p = iter.next_addr(); 252 adjust_pointer(p); 253 } 254 } 255 256 void MarkSweep::restore_marks() { 257 assert(_preserved_oop_stack.size() == _preserved_mark_stack.size(), 258 "inconsistent preserved oop stacks"); 259 log_trace(gc)("Restoring " SIZE_FORMAT " marks", _preserved_count + _preserved_oop_stack.size()); 260 261 // restore the marks we saved earlier 262 for (size_t i = 0; i < _preserved_count; i++) { 263 _preserved_marks[i].restore(); 264 } 265 266 // deal with the overflow 267 while (!_preserved_oop_stack.is_empty()) { 268 oop obj = _preserved_oop_stack.pop(); 269 markOop mark = _preserved_mark_stack.pop(); 270 obj->set_mark(mark); 271 } 272 } 273 274 bool MarkSweep::IsAliveClosure::do_object_b(oop p) { return p->is_gc_marked() || is_archive_object(p); } 275 276 void MarkSweep::KeepAliveClosure::do_oop(oop* p) { do_oop_work(p); } 277 void MarkSweep::KeepAliveClosure::do_oop(narrowOop* p) { do_oop_work(p); } 278 279 void marksweep_init() { 280 MarkSweep::_gc_timer = new (ResourceObj::C_HEAP, mtGC) STWGCTimer(); 281 MarkSweep::_gc_tracer = new (ResourceObj::C_HEAP, mtGC) SerialOldTracer(); 282 } 283 284 int InstanceKlass::oop_ms_adjust_pointers(oop obj, MarkSweep* ms) { 285 int size = size_helper(); 286 oop_oop_iterate_oop_maps<true>(obj, &ms->adjust_pointer_closure); 287 return size; 288 } 289 290 int InstanceMirrorKlass::oop_ms_adjust_pointers(oop obj, MarkSweep* ms) { 291 int size = oop_size(obj); 292 InstanceKlass::oop_ms_adjust_pointers(obj, ms); 293 294 oop_oop_iterate_statics<true>(obj, &ms->adjust_pointer_closure); 295 return size; 296 } 297 298 int InstanceClassLoaderKlass::oop_ms_adjust_pointers(oop obj, MarkSweep* ms) { 299 return InstanceKlass::oop_ms_adjust_pointers(obj, ms); 300 } 301 302 #ifdef ASSERT 303 template <class T> static void trace_reference_gc(const char *s, oop obj, 304 T* referent_addr, 305 T* next_addr, 306 T* discovered_addr) { 307 log_develop_trace(gc, ref)("%s obj " PTR_FORMAT, s, p2i(obj)); 308 log_develop_trace(gc, ref)(" referent_addr/* " PTR_FORMAT " / " PTR_FORMAT, 309 p2i(referent_addr), p2i(referent_addr ? (address)oopDesc::load_decode_heap_oop(referent_addr) : NULL)); 310 log_develop_trace(gc, ref)(" next_addr/* " PTR_FORMAT " / " PTR_FORMAT, 311 p2i(next_addr), p2i(next_addr ? (address)oopDesc::load_decode_heap_oop(next_addr) : NULL)); 312 log_develop_trace(gc, ref)(" discovered_addr/* " PTR_FORMAT " / " PTR_FORMAT, 313 p2i(discovered_addr), p2i(discovered_addr ? (address)oopDesc::load_decode_heap_oop(discovered_addr) : NULL)); 314 } 315 #endif 316 317 template <class T> void static adjust_object_specialized(oop obj) { 318 T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj); 319 MarkSweep::adjust_pointer(referent_addr); 320 T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj); 321 MarkSweep::adjust_pointer(next_addr); 322 T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj); 323 MarkSweep::adjust_pointer(discovered_addr); 324 debug_only(trace_reference_gc("InstanceRefKlass::oop_ms_adjust_pointers", obj, 325 referent_addr, next_addr, discovered_addr);) 326 } 327 328 int InstanceRefKlass::oop_ms_adjust_pointers(oop obj, MarkSweep* ms) { 329 int size = size_helper(); 330 InstanceKlass::oop_ms_adjust_pointers(obj, ms); 331 332 if (UseCompressedOops) { 333 adjust_object_specialized<narrowOop>(obj); 334 } else { 335 adjust_object_specialized<oop>(obj); 336 } 337 return size; 338 } 339 340 int ObjArrayKlass::oop_ms_adjust_pointers(oop obj, MarkSweep* ms) { 341 assert(obj->is_objArray(), "obj must be obj array"); 342 objArrayOop a = objArrayOop(obj); 343 // Get size before changing pointers. 344 // Don't call size() or oop_size() since that is a virtual call. 345 int size = a->object_size(); 346 oop_oop_iterate_elements<true>(a, &ms->adjust_pointer_closure); 347 return size; 348 } 349 350 int TypeArrayKlass::oop_ms_adjust_pointers(oop obj, MarkSweep* /* ms */) { 351 assert(obj->is_typeArray(), "must be a type array"); 352 typeArrayOop t = typeArrayOop(obj); 353 // Performance tweak: We skip iterating over the klass pointer since we 354 // know that Universe::TypeArrayKlass never moves. 355 return t->object_size(); 356 } 357 358 // Generate MS specialized oop_oop_iterate functions. 359 SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_MS(ALL_KLASS_OOP_OOP_ITERATE_DEFN)