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