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/instanceKlass.inline.hpp" 34 #include "oops/instanceMirrorKlass.inline.hpp" 35 #include "oops/methodData.hpp" 36 #include "oops/objArrayKlass.inline.hpp" 37 #include "oops/oop.inline.hpp" 38 39 uint MarkSweep::_total_invocations = 0; 40 41 Stack<oop, mtGC> MarkSweep::_marking_stack; 42 Stack<ObjArrayTask, mtGC> MarkSweep::_objarray_stack; 43 44 Stack<oop, mtGC> MarkSweep::_preserved_oop_stack; 45 Stack<markOop, mtGC> MarkSweep::_preserved_mark_stack; 46 size_t MarkSweep::_preserved_count = 0; 47 size_t MarkSweep::_preserved_count_max = 0; 48 PreservedMark* MarkSweep::_preserved_marks = NULL; 49 ReferenceProcessor* MarkSweep::_ref_processor = NULL; 50 STWGCTimer* MarkSweep::_gc_timer = NULL; 51 SerialOldTracer* MarkSweep::_gc_tracer = NULL; 52 53 MarkSweep::FollowRootClosure MarkSweep::follow_root_closure; 54 55 void MarkSweep::FollowRootClosure::do_oop(oop* p) { follow_root(p); } 56 void MarkSweep::FollowRootClosure::do_oop(narrowOop* p) { follow_root(p); } 57 58 MarkAndPushClosure MarkSweep::mark_and_push_closure; 59 CLDToOopClosure MarkSweep::follow_cld_closure(&mark_and_push_closure); 60 CLDToOopClosure MarkSweep::adjust_cld_closure(&adjust_pointer_closure); 61 62 template <typename T> 63 void MarkAndPushClosure::do_oop_nv(T* p) { MarkSweep::mark_and_push(p); } 64 void MarkAndPushClosure::do_oop(oop* p) { do_oop_nv(p); } 65 void MarkAndPushClosure::do_oop(narrowOop* p) { do_oop_nv(p); } 66 bool MarkAndPushClosure::do_metadata() { return do_metadata_nv(); } 67 bool MarkAndPushClosure::do_metadata_nv() { return true; } 68 void MarkAndPushClosure::do_klass(Klass* k) { do_klass_nv(k); } 69 void MarkAndPushClosure::do_klass_nv(Klass* k) { MarkSweep::follow_klass(k); } 70 void MarkAndPushClosure::do_cld(ClassLoaderData* cld) { do_cld_nv(cld); } 71 void MarkAndPushClosure::do_cld_nv(ClassLoaderData* cld) { MarkSweep::follow_cld(cld); } 72 73 void MarkSweep::follow_array(objArrayOop array, int index) { 74 const int len = array->length(); 75 const int beg_index = index; 76 assert(beg_index < len || len == 0, "index too large"); 77 78 const int stride = MIN2(len - beg_index, (int) ObjArrayMarkingStride); 79 const int end_index = beg_index + stride; 80 81 array->oop_iterate_range(&mark_and_push_closure, beg_index, end_index); 82 83 if (end_index < len) { 84 MarkSweep::push_objarray(array, end_index); // Push the continuation. 85 } 86 } 87 88 void MarkSweep::follow_stack() { 89 do { 90 while (!_marking_stack.is_empty()) { 91 oop obj = _marking_stack.pop(); 92 assert (obj->is_gc_marked(), "p must be marked"); 93 follow_object(obj); 94 } 95 // Process ObjArrays one at a time to avoid marking stack bloat. 96 if (!_objarray_stack.is_empty()) { 97 ObjArrayTask task = _objarray_stack.pop(); 98 follow_array(objArrayOop(task.obj()), task.index()); 99 } 100 } while (!_marking_stack.is_empty() || !_objarray_stack.is_empty()); 101 } 102 103 MarkSweep::FollowStackClosure MarkSweep::follow_stack_closure; 104 105 void MarkSweep::FollowStackClosure::do_void() { follow_stack(); } 106 107 void PreservedMark::adjust_pointer() { 108 MarkSweep::adjust_pointer(&_obj); 109 } 110 111 void PreservedMark::restore() { 112 _obj->set_mark(_mark); 113 } 114 115 // We preserve the mark which should be replaced at the end and the location 116 // that it will go. Note that the object that this markOop belongs to isn't 117 // currently at that address but it will be after phase4 118 void MarkSweep::preserve_mark(oop obj, markOop mark) { 119 // We try to store preserved marks in the to space of the new generation since 120 // this is storage which should be available. Most of the time this should be 121 // sufficient space for the marks we need to preserve but if it isn't we fall 122 // back to using Stacks to keep track of the overflow. 123 if (_preserved_count < _preserved_count_max) { 124 _preserved_marks[_preserved_count++].init(obj, mark); 125 } else { 126 _preserved_mark_stack.push(mark); 127 _preserved_oop_stack.push(obj); 128 } 129 } 130 131 void MarkSweep::set_ref_processor(ReferenceProcessor* rp) { 132 _ref_processor = rp; 133 mark_and_push_closure.set_ref_processor(_ref_processor); 134 } 135 136 MarkSweep::AdjustPointerClosure MarkSweep::adjust_pointer_closure; 137 138 template <typename T> 139 void MarkSweep::AdjustPointerClosure::do_oop_nv(T* p) { adjust_pointer(p); } 140 void MarkSweep::AdjustPointerClosure::do_oop(oop* p) { do_oop_nv(p); } 141 void MarkSweep::AdjustPointerClosure::do_oop(narrowOop* p) { do_oop_nv(p); } 142 143 void MarkSweep::adjust_marks() { 144 assert( _preserved_oop_stack.size() == _preserved_mark_stack.size(), 145 "inconsistent preserved oop stacks"); 146 147 // adjust the oops we saved earlier 148 for (size_t i = 0; i < _preserved_count; i++) { 149 _preserved_marks[i].adjust_pointer(); 150 } 151 152 // deal with the overflow stack 153 StackIterator<oop, mtGC> iter(_preserved_oop_stack); 154 while (!iter.is_empty()) { 155 oop* p = iter.next_addr(); 156 adjust_pointer(p); 157 } 158 } 159 160 void MarkSweep::restore_marks() { 161 assert(_preserved_oop_stack.size() == _preserved_mark_stack.size(), 162 "inconsistent preserved oop stacks"); 163 if (PrintGC && Verbose) { 164 gclog_or_tty->print_cr("Restoring " SIZE_FORMAT " marks", 165 _preserved_count + _preserved_oop_stack.size()); 166 } 167 168 // restore the marks we saved earlier 169 for (size_t i = 0; i < _preserved_count; i++) { 170 _preserved_marks[i].restore(); 171 } 172 173 // deal with the overflow 174 while (!_preserved_oop_stack.is_empty()) { 175 oop obj = _preserved_oop_stack.pop(); 176 markOop mark = _preserved_mark_stack.pop(); 177 obj->set_mark(mark); 178 } 179 } 180 181 MarkSweep::IsAliveClosure MarkSweep::is_alive; 182 183 bool MarkSweep::IsAliveClosure::do_object_b(oop p) { return p->is_gc_marked() || is_archive_object(p); } 184 185 MarkSweep::KeepAliveClosure MarkSweep::keep_alive; 186 187 void MarkSweep::KeepAliveClosure::do_oop(oop* p) { MarkSweep::KeepAliveClosure::do_oop_work(p); } 188 void MarkSweep::KeepAliveClosure::do_oop(narrowOop* p) { MarkSweep::KeepAliveClosure::do_oop_work(p); } 189 190 void marksweep_init() { 191 MarkSweep::_gc_timer = new (ResourceObj::C_HEAP, mtGC) STWGCTimer(); 192 MarkSweep::_gc_tracer = new (ResourceObj::C_HEAP, mtGC) SerialOldTracer(); 193 } 194 195 int InstanceKlass::oop_ms_adjust_pointers(oop obj) { 196 int size = size_helper(); 197 oop_oop_iterate_oop_maps<true>(obj, &MarkSweep::adjust_pointer_closure); 198 return size; 199 } 200 201 int InstanceMirrorKlass::oop_ms_adjust_pointers(oop obj) { 202 int size = oop_size(obj); 203 InstanceKlass::oop_ms_adjust_pointers(obj); 204 205 oop_oop_iterate_statics<true>(obj, &MarkSweep::adjust_pointer_closure); 206 return size; 207 } 208 209 int InstanceClassLoaderKlass::oop_ms_adjust_pointers(oop obj) { 210 return InstanceKlass::oop_ms_adjust_pointers(obj); 211 } 212 213 #ifdef ASSERT 214 template <class T> static void trace_reference_gc(const char *s, oop obj, 215 T* referent_addr, 216 T* next_addr, 217 T* discovered_addr) { 218 if(TraceReferenceGC && PrintGCDetails) { 219 gclog_or_tty->print_cr("%s obj " PTR_FORMAT, s, p2i(obj)); 220 gclog_or_tty->print_cr(" referent_addr/* " PTR_FORMAT " / " 221 PTR_FORMAT, p2i(referent_addr), 222 p2i(referent_addr ? 223 (address)oopDesc::load_decode_heap_oop(referent_addr) : NULL)); 224 gclog_or_tty->print_cr(" next_addr/* " PTR_FORMAT " / " 225 PTR_FORMAT, p2i(next_addr), 226 p2i(next_addr ? (address)oopDesc::load_decode_heap_oop(next_addr) : NULL)); 227 gclog_or_tty->print_cr(" discovered_addr/* " PTR_FORMAT " / " 228 PTR_FORMAT, p2i(discovered_addr), 229 p2i(discovered_addr ? 230 (address)oopDesc::load_decode_heap_oop(discovered_addr) : NULL)); 231 } 232 } 233 #endif 234 235 template <class T> void static adjust_object_specialized(oop obj) { 236 T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj); 237 MarkSweep::adjust_pointer(referent_addr); 238 T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj); 239 MarkSweep::adjust_pointer(next_addr); 240 T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj); 241 MarkSweep::adjust_pointer(discovered_addr); 242 debug_only(trace_reference_gc("InstanceRefKlass::oop_ms_adjust_pointers", obj, 243 referent_addr, next_addr, discovered_addr);) 244 } 245 246 int InstanceRefKlass::oop_ms_adjust_pointers(oop obj) { 247 int size = size_helper(); 248 InstanceKlass::oop_ms_adjust_pointers(obj); 249 250 if (UseCompressedOops) { 251 adjust_object_specialized<narrowOop>(obj); 252 } else { 253 adjust_object_specialized<oop>(obj); 254 } 255 return size; 256 } 257 258 int ObjArrayKlass::oop_ms_adjust_pointers(oop obj) { 259 assert(obj->is_objArray(), "obj must be obj array"); 260 objArrayOop a = objArrayOop(obj); 261 // Get size before changing pointers. 262 // Don't call size() or oop_size() since that is a virtual call. 263 int size = a->object_size(); 264 oop_oop_iterate_elements<true>(a, &MarkSweep::adjust_pointer_closure); 265 return size; 266 } 267 268 int TypeArrayKlass::oop_ms_adjust_pointers(oop obj) { 269 assert(obj->is_typeArray(), "must be a type array"); 270 typeArrayOop t = typeArrayOop(obj); 271 // Performance tweak: We skip iterating over the klass pointer since we 272 // know that Universe::TypeArrayKlass never moves. 273 return t->object_size(); 274 } 275 276 // Generate MS specialized oop_oop_iterate functions. 277 SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_MS(ALL_KLASS_OOP_OOP_ITERATE_DEFN)