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 44 uint MarkSweep::_total_invocations = 0; 45 46 Stack<oop, mtGC> MarkSweep::_marking_stack; 47 Stack<ObjArrayTask, mtGC> MarkSweep::_objarray_stack; 48 49 Stack<oop, mtGC> MarkSweep::_preserved_oop_stack; 50 Stack<markOop, mtGC> MarkSweep::_preserved_mark_stack; 51 size_t MarkSweep::_preserved_count = 0; 52 size_t MarkSweep::_preserved_count_max = 0; 56 SerialOldTracer* MarkSweep::_gc_tracer = NULL; 57 58 MarkSweep::FollowRootClosure MarkSweep::follow_root_closure; 59 60 MarkAndPushClosure MarkSweep::mark_and_push_closure; 61 CLDToOopClosure MarkSweep::follow_cld_closure(&mark_and_push_closure); 62 CLDToOopClosure MarkSweep::adjust_cld_closure(&adjust_pointer_closure); 63 64 inline void MarkSweep::mark_object(oop obj) { 65 // some marks may contain information we need to preserve so we store them away 66 // and overwrite the mark. We'll restore it at the end of markSweep. 67 markOop mark = obj->mark(); 68 obj->set_mark(markOopDesc::prototype()->set_marked()); 69 70 if (mark->must_be_preserved(obj)) { 71 preserve_mark(obj, mark); 72 } 73 } 74 75 template <class T> inline void MarkSweep::mark_and_push(T* p) { 76 T heap_oop = oopDesc::load_heap_oop(p); 77 if (!oopDesc::is_null(heap_oop)) { 78 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); 79 if (!obj->mark()->is_marked()) { 80 mark_object(obj); 81 _marking_stack.push(obj); 82 } 83 } 84 } 85 86 inline void MarkSweep::follow_klass(Klass* klass) { 87 oop op = klass->klass_holder(); 88 MarkSweep::mark_and_push(&op); 89 } 90 91 inline void MarkSweep::follow_cld(ClassLoaderData* cld) { 92 MarkSweep::follow_cld_closure.do_cld(cld); 93 } 94 95 template <typename T> 96 inline void MarkAndPushClosure::do_oop_nv(T* p) { MarkSweep::mark_and_push(p); } 97 void MarkAndPushClosure::do_oop(oop* p) { do_oop_nv(p); } 98 void MarkAndPushClosure::do_oop(narrowOop* p) { do_oop_nv(p); } 152 while (!_marking_stack.is_empty()) { 153 oop obj = _marking_stack.pop(); 154 assert (obj->is_gc_marked(), "p must be marked"); 155 follow_object(obj); 156 } 157 // Process ObjArrays one at a time to avoid marking stack bloat. 158 if (!_objarray_stack.is_empty()) { 159 ObjArrayTask task = _objarray_stack.pop(); 160 follow_array_chunk(objArrayOop(task.obj()), task.index()); 161 } 162 } while (!_marking_stack.is_empty() || !_objarray_stack.is_empty()); 163 } 164 165 MarkSweep::FollowStackClosure MarkSweep::follow_stack_closure; 166 167 void MarkSweep::FollowStackClosure::do_void() { follow_stack(); } 168 169 template <class T> inline void MarkSweep::follow_root(T* p) { 170 assert(!Universe::heap()->is_in_reserved(p), 171 "roots shouldn't be things within the heap"); 172 T heap_oop = oopDesc::load_heap_oop(p); 173 if (!oopDesc::is_null(heap_oop)) { 174 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); 175 if (!obj->mark()->is_marked()) { 176 mark_object(obj); 177 follow_object(obj); 178 } 179 } 180 follow_stack(); 181 } 182 183 void MarkSweep::FollowRootClosure::do_oop(oop* p) { follow_root(p); } 184 void MarkSweep::FollowRootClosure::do_oop(narrowOop* p) { follow_root(p); } 185 186 void PreservedMark::adjust_pointer() { 187 MarkSweep::adjust_pointer(&_obj); 188 } 189 190 void PreservedMark::restore() { 191 _obj->set_mark(_mark); 192 } 193 194 // We preserve the mark which should be replaced at the end and the location | 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/access.inline.hpp" 34 #include "oops/compressedOops.inline.hpp" 35 #include "oops/instanceClassLoaderKlass.inline.hpp" 36 #include "oops/instanceKlass.inline.hpp" 37 #include "oops/instanceMirrorKlass.inline.hpp" 38 #include "oops/instanceRefKlass.inline.hpp" 39 #include "oops/methodData.hpp" 40 #include "oops/objArrayKlass.inline.hpp" 41 #include "oops/oop.inline.hpp" 42 #include "oops/typeArrayOop.inline.hpp" 43 #include "utilities/macros.hpp" 44 #include "utilities/stack.inline.hpp" 45 46 uint MarkSweep::_total_invocations = 0; 47 48 Stack<oop, mtGC> MarkSweep::_marking_stack; 49 Stack<ObjArrayTask, mtGC> MarkSweep::_objarray_stack; 50 51 Stack<oop, mtGC> MarkSweep::_preserved_oop_stack; 52 Stack<markOop, mtGC> MarkSweep::_preserved_mark_stack; 53 size_t MarkSweep::_preserved_count = 0; 54 size_t MarkSweep::_preserved_count_max = 0; 58 SerialOldTracer* MarkSweep::_gc_tracer = NULL; 59 60 MarkSweep::FollowRootClosure MarkSweep::follow_root_closure; 61 62 MarkAndPushClosure MarkSweep::mark_and_push_closure; 63 CLDToOopClosure MarkSweep::follow_cld_closure(&mark_and_push_closure); 64 CLDToOopClosure MarkSweep::adjust_cld_closure(&adjust_pointer_closure); 65 66 inline void MarkSweep::mark_object(oop obj) { 67 // some marks may contain information we need to preserve so we store them away 68 // and overwrite the mark. We'll restore it at the end of markSweep. 69 markOop mark = obj->mark(); 70 obj->set_mark(markOopDesc::prototype()->set_marked()); 71 72 if (mark->must_be_preserved(obj)) { 73 preserve_mark(obj, mark); 74 } 75 } 76 77 template <class T> inline void MarkSweep::mark_and_push(T* p) { 78 T heap_oop = RawAccess<>::oop_load(p); 79 if (!CompressedOops::is_null(heap_oop)) { 80 oop obj = CompressedOops::decode_not_null(heap_oop); 81 if (!obj->mark()->is_marked()) { 82 mark_object(obj); 83 _marking_stack.push(obj); 84 } 85 } 86 } 87 88 inline void MarkSweep::follow_klass(Klass* klass) { 89 oop op = klass->klass_holder(); 90 MarkSweep::mark_and_push(&op); 91 } 92 93 inline void MarkSweep::follow_cld(ClassLoaderData* cld) { 94 MarkSweep::follow_cld_closure.do_cld(cld); 95 } 96 97 template <typename T> 98 inline void MarkAndPushClosure::do_oop_nv(T* p) { MarkSweep::mark_and_push(p); } 99 void MarkAndPushClosure::do_oop(oop* p) { do_oop_nv(p); } 100 void MarkAndPushClosure::do_oop(narrowOop* p) { do_oop_nv(p); } 154 while (!_marking_stack.is_empty()) { 155 oop obj = _marking_stack.pop(); 156 assert (obj->is_gc_marked(), "p must be marked"); 157 follow_object(obj); 158 } 159 // Process ObjArrays one at a time to avoid marking stack bloat. 160 if (!_objarray_stack.is_empty()) { 161 ObjArrayTask task = _objarray_stack.pop(); 162 follow_array_chunk(objArrayOop(task.obj()), task.index()); 163 } 164 } while (!_marking_stack.is_empty() || !_objarray_stack.is_empty()); 165 } 166 167 MarkSweep::FollowStackClosure MarkSweep::follow_stack_closure; 168 169 void MarkSweep::FollowStackClosure::do_void() { follow_stack(); } 170 171 template <class T> inline void MarkSweep::follow_root(T* p) { 172 assert(!Universe::heap()->is_in_reserved(p), 173 "roots shouldn't be things within the heap"); 174 T heap_oop = RawAccess<>::oop_load(p); 175 if (!CompressedOops::is_null(heap_oop)) { 176 oop obj = CompressedOops::decode_not_null(heap_oop); 177 if (!obj->mark()->is_marked()) { 178 mark_object(obj); 179 follow_object(obj); 180 } 181 } 182 follow_stack(); 183 } 184 185 void MarkSweep::FollowRootClosure::do_oop(oop* p) { follow_root(p); } 186 void MarkSweep::FollowRootClosure::do_oop(narrowOop* p) { follow_root(p); } 187 188 void PreservedMark::adjust_pointer() { 189 MarkSweep::adjust_pointer(&_obj); 190 } 191 192 void PreservedMark::restore() { 193 _obj->set_mark(_mark); 194 } 195 196 // We preserve the mark which should be replaced at the end and the location |