duke@435: /* minqi@5097: * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved. duke@435: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. duke@435: * duke@435: * This code is free software; you can redistribute it and/or modify it duke@435: * under the terms of the GNU General Public License version 2 only, as duke@435: * published by the Free Software Foundation. duke@435: * duke@435: * This code is distributed in the hope that it will be useful, but WITHOUT duke@435: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or duke@435: * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License duke@435: * version 2 for more details (a copy is included in the LICENSE file that duke@435: * accompanied this code). duke@435: * duke@435: * You should have received a copy of the GNU General Public License version duke@435: * 2 along with this work; if not, write to the Free Software Foundation, duke@435: * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. duke@435: * trims@1907: * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA trims@1907: * or visit www.oracle.com if you need additional information or have any trims@1907: * questions. duke@435: * duke@435: */ duke@435: stefank@2314: #include "precompiled.hpp" stefank@2314: #include "compiler/compileBroker.hpp" stefank@2314: #include "gc_implementation/shared/markSweep.inline.hpp" stefank@2314: #include "gc_interface/collectedHeap.inline.hpp" coleenp@4037: #include "oops/methodData.hpp" stefank@2314: #include "oops/objArrayKlass.inline.hpp" stefank@2314: #include "oops/oop.inline.hpp" duke@435: tschatzl@5119: uint MarkSweep::_total_invocations = 0; coleenp@4037: zgu@3900: Stack MarkSweep::_marking_stack; zgu@3900: Stack MarkSweep::_objarray_stack; duke@435: zgu@3900: Stack MarkSweep::_preserved_oop_stack; zgu@3900: Stack MarkSweep::_preserved_mark_stack; duke@435: size_t MarkSweep::_preserved_count = 0; duke@435: size_t MarkSweep::_preserved_count_max = 0; duke@435: PreservedMark* MarkSweep::_preserved_marks = NULL; duke@435: ReferenceProcessor* MarkSweep::_ref_processor = NULL; duke@435: coleenp@548: MarkSweep::FollowRootClosure MarkSweep::follow_root_closure; jrose@1424: CodeBlobToOopClosure MarkSweep::follow_code_root_closure(&MarkSweep::follow_root_closure, /*do_marking=*/ true); duke@435: coleenp@548: void MarkSweep::FollowRootClosure::do_oop(oop* p) { follow_root(p); } coleenp@548: void MarkSweep::FollowRootClosure::do_oop(narrowOop* p) { follow_root(p); } duke@435: duke@435: MarkSweep::MarkAndPushClosure MarkSweep::mark_and_push_closure; coleenp@4037: MarkSweep::FollowKlassClosure MarkSweep::follow_klass_closure; coleenp@4037: MarkSweep::AdjustKlassClosure MarkSweep::adjust_klass_closure; duke@435: coleenp@4037: void MarkSweep::MarkAndPushClosure::do_oop(oop* p) { mark_and_push(p); } coleenp@548: void MarkSweep::MarkAndPushClosure::do_oop(narrowOop* p) { mark_and_push(p); } duke@435: coleenp@4037: void MarkSweep::FollowKlassClosure::do_klass(Klass* klass) { coleenp@4037: klass->oops_do(&MarkSweep::mark_and_push_closure); coleenp@4037: } coleenp@4037: void MarkSweep::AdjustKlassClosure::do_klass(Klass* klass) { coleenp@4037: klass->oops_do(&MarkSweep::adjust_pointer_closure); coleenp@4037: } coleenp@4037: coleenp@4037: void MarkSweep::follow_klass(Klass* klass) { coleenp@4037: ClassLoaderData* cld = klass->class_loader_data(); coleenp@4037: // The actual processing of the klass is done when we coleenp@4037: // traverse the list of Klasses in the class loader data. coleenp@4037: MarkSweep::follow_class_loader(cld); coleenp@4037: } coleenp@4037: coleenp@4037: void MarkSweep::adjust_klass(Klass* klass) { coleenp@4037: ClassLoaderData* cld = klass->class_loader_data(); coleenp@4037: // The actual processing of the klass is done when we coleenp@4037: // traverse the list of Klasses in the class loader data. coleenp@4037: MarkSweep::adjust_class_loader(cld); coleenp@4037: } coleenp@4037: coleenp@4037: void MarkSweep::follow_class_loader(ClassLoaderData* cld) { coleenp@4037: cld->oops_do(&MarkSweep::mark_and_push_closure, &MarkSweep::follow_klass_closure, true); coleenp@4037: } coleenp@4037: coleenp@4037: void MarkSweep::adjust_class_loader(ClassLoaderData* cld) { stefank@5011: cld->oops_do(&MarkSweep::adjust_pointer_closure, &MarkSweep::adjust_klass_closure, true); coleenp@4037: } coleenp@4037: coleenp@4037: duke@435: void MarkSweep::follow_stack() { jcoomes@1746: do { jcoomes@2191: while (!_marking_stack.is_empty()) { jcoomes@2191: oop obj = _marking_stack.pop(); jcoomes@1746: assert (obj->is_gc_marked(), "p must be marked"); jcoomes@1746: obj->follow_contents(); jcoomes@1746: } jcoomes@1750: // Process ObjArrays one at a time to avoid marking stack bloat. jcoomes@2191: if (!_objarray_stack.is_empty()) { jcoomes@2191: ObjArrayTask task = _objarray_stack.pop(); minqi@5097: ObjArrayKlass* k = (ObjArrayKlass*)task.obj()->klass(); jcoomes@1746: k->oop_follow_contents(task.obj(), task.index()); jcoomes@1746: } jcoomes@2191: } while (!_marking_stack.is_empty() || !_objarray_stack.is_empty()); duke@435: } duke@435: duke@435: MarkSweep::FollowStackClosure MarkSweep::follow_stack_closure; duke@435: coleenp@548: void MarkSweep::FollowStackClosure::do_void() { follow_stack(); } duke@435: jcoomes@2191: // We preserve the mark which should be replaced at the end and the location jcoomes@2191: // that it will go. Note that the object that this markOop belongs to isn't jcoomes@2191: // currently at that address but it will be after phase4 duke@435: void MarkSweep::preserve_mark(oop obj, markOop mark) { jcoomes@2191: // We try to store preserved marks in the to space of the new generation since jcoomes@2191: // this is storage which should be available. Most of the time this should be jcoomes@2191: // sufficient space for the marks we need to preserve but if it isn't we fall jcoomes@2191: // back to using Stacks to keep track of the overflow. duke@435: if (_preserved_count < _preserved_count_max) { duke@435: _preserved_marks[_preserved_count++].init(obj, mark); duke@435: } else { jcoomes@2191: _preserved_mark_stack.push(mark); jcoomes@2191: _preserved_oop_stack.push(obj); duke@435: } duke@435: } duke@435: stefank@5011: MarkSweep::AdjustPointerClosure MarkSweep::adjust_pointer_closure; duke@435: stefank@5011: void MarkSweep::AdjustPointerClosure::do_oop(oop* p) { adjust_pointer(p); } stefank@5011: void MarkSweep::AdjustPointerClosure::do_oop(narrowOop* p) { adjust_pointer(p); } coleenp@548: duke@435: void MarkSweep::adjust_marks() { jcoomes@2191: assert( _preserved_oop_stack.size() == _preserved_mark_stack.size(), duke@435: "inconsistent preserved oop stacks"); duke@435: duke@435: // adjust the oops we saved earlier duke@435: for (size_t i = 0; i < _preserved_count; i++) { duke@435: _preserved_marks[i].adjust_pointer(); duke@435: } duke@435: duke@435: // deal with the overflow stack zgu@3900: StackIterator iter(_preserved_oop_stack); jcoomes@2191: while (!iter.is_empty()) { jcoomes@2191: oop* p = iter.next_addr(); jcoomes@2191: adjust_pointer(p); duke@435: } duke@435: } duke@435: duke@435: void MarkSweep::restore_marks() { jcoomes@2191: assert(_preserved_oop_stack.size() == _preserved_mark_stack.size(), duke@435: "inconsistent preserved oop stacks"); duke@435: if (PrintGC && Verbose) { jcoomes@2191: gclog_or_tty->print_cr("Restoring %d marks", jcoomes@2191: _preserved_count + _preserved_oop_stack.size()); duke@435: } duke@435: duke@435: // restore the marks we saved earlier duke@435: for (size_t i = 0; i < _preserved_count; i++) { duke@435: _preserved_marks[i].restore(); duke@435: } duke@435: duke@435: // deal with the overflow jcoomes@2191: while (!_preserved_oop_stack.is_empty()) { jcoomes@2191: oop obj = _preserved_oop_stack.pop(); jcoomes@2191: markOop mark = _preserved_mark_stack.pop(); jcoomes@2191: obj->set_mark(mark); duke@435: } duke@435: } duke@435: coleenp@548: MarkSweep::IsAliveClosure MarkSweep::is_alive; duke@435: coleenp@548: bool MarkSweep::IsAliveClosure::do_object_b(oop p) { return p->is_gc_marked(); } duke@435: duke@435: MarkSweep::KeepAliveClosure MarkSweep::keep_alive; duke@435: coleenp@548: void MarkSweep::KeepAliveClosure::do_oop(oop* p) { MarkSweep::KeepAliveClosure::do_oop_work(p); } coleenp@548: void MarkSweep::KeepAliveClosure::do_oop(narrowOop* p) { MarkSweep::KeepAliveClosure::do_oop_work(p); } coleenp@548: duke@435: void marksweep_init() { /* empty */ } duke@435: duke@435: #ifndef PRODUCT duke@435: duke@435: void MarkSweep::trace(const char* msg) { duke@435: if (TraceMarkSweep) duke@435: gclog_or_tty->print("%s", msg); duke@435: } duke@435: duke@435: #endif