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 "oops/instanceKlass.inline.hpp"

    32 #include "oops/instanceMirrorKlass.inline.hpp"

    33 #include "oops/methodData.hpp"

    34 #include "oops/objArrayKlass.inline.hpp"

    35 #include "oops/oop.inline.hpp"

    36 

    37 uint                    MarkSweep::_total_invocations = 0;

    38 

    39 Stack<oop, mtGC>              MarkSweep::_marking_stack;

    40 Stack<ObjArrayTask, mtGC>     MarkSweep::_objarray_stack;

    41 

    42 Stack<oop, mtGC>              MarkSweep::_preserved_oop_stack;

    43 Stack<markOop, mtGC>          MarkSweep::_preserved_mark_stack;

    44 size_t                  MarkSweep::_preserved_count = 0;

    45 size_t                  MarkSweep::_preserved_count_max = 0;

    46 PreservedMark*          MarkSweep::_preserved_marks = NULL;

    47 ReferenceProcessor*     MarkSweep::_ref_processor   = NULL;

    48 STWGCTimer*             MarkSweep::_gc_timer        = NULL;

    49 SerialOldTracer*        MarkSweep::_gc_tracer       = NULL;

    50 

    51 MarkSweep::FollowRootClosure  MarkSweep::follow_root_closure;

    52 

    53 void MarkSweep::FollowRootClosure::do_oop(oop* p)       { follow_root(p); }

    54 void MarkSweep::FollowRootClosure::do_oop(narrowOop* p) { follow_root(p); }

    55 

    56 MarkSweep::MarkAndPushClosure MarkSweep::mark_and_push_closure;

    57 CLDToOopClosure               MarkSweep::follow_cld_closure(&mark_and_push_closure);

    58 CLDToOopClosure               MarkSweep::adjust_cld_closure(&adjust_pointer_closure);

    59 

    60 template <typename T>

    61 void MarkSweep::MarkAndPushClosure::do_oop_nv(T* p)       { mark_and_push(p); }

    62 void MarkSweep::MarkAndPushClosure::do_oop(oop* p)        { do_oop_nv(p); }

    63 void MarkSweep::MarkAndPushClosure::do_oop(narrowOop* p)  { do_oop_nv(p); }

    64 

    65 void MarkSweep::follow_class_loader(ClassLoaderData* cld) {

    66   MarkSweep::follow_cld_closure.do_cld(cld);

    67 }

    68 

    69 void InstanceKlass::oop_ms_follow_contents(oop obj) {

    70   assert(obj != NULL, "can't follow the content of NULL object");

    71   MarkSweep::follow_klass(this);

    72 

    73   oop_oop_iterate_oop_maps<true>(obj, &MarkSweep::mark_and_push_closure);

    74 }

    75 

    76 void InstanceMirrorKlass::oop_ms_follow_contents(oop obj) {

    77   InstanceKlass::oop_ms_follow_contents(obj);

    78 

    79   // Follow the klass field in the mirror

    80   Klass* klass = java_lang_Class::as_Klass(obj);

    81   if (klass != NULL) {

    82     // An anonymous class doesn't have its own class loader, so the call

    83     // to follow_klass will mark and push its java mirror instead of the

    84     // class loader. When handling the java mirror for an anonymous class

    85     // we need to make sure its class loader data is claimed, this is done

    86     // by calling follow_class_loader explicitly. For non-anonymous classes

    87     // the call to follow_class_loader is made when the class loader itself

    88     // is handled.

    89     if (klass->oop_is_instance() && InstanceKlass::cast(klass)->is_anonymous()) {

    90       MarkSweep::follow_class_loader(klass->class_loader_data());

    91     } else {

    92       MarkSweep::follow_klass(klass);

    93     }

    94   } else {

    95     // If klass is NULL then this a mirror for a primitive type.

    96     // We don't have to follow them, since they are handled as strong

    97     // roots in Universe::oops_do.

    98     assert(java_lang_Class::is_primitive(obj), "Sanity check");

    99   }

   100 

   101   oop_oop_iterate_statics<true>(obj, &MarkSweep::mark_and_push_closure);

   102 }

   103 

   104 void InstanceClassLoaderKlass::oop_ms_follow_contents(oop obj) {

   105   InstanceKlass::oop_ms_follow_contents(obj);

   106 

   107   ClassLoaderData * const loader_data = java_lang_ClassLoader::loader_data(obj);

   108 

   109   // We must NULL check here, since the class loader

   110   // can be found before the loader data has been set up.

   111   if(loader_data != NULL) {

   112     MarkSweep::follow_class_loader(loader_data);

   113   }

   114 }

   115 

   116 template <class T>

   117 static void oop_ms_follow_contents_specialized(InstanceRefKlass* klass, oop obj) {

   118   T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);

   119   T heap_oop = oopDesc::load_heap_oop(referent_addr);

   120   debug_only(

   121     if(TraceReferenceGC && PrintGCDetails) {

   122       gclog_or_tty->print_cr("InstanceRefKlass::oop_ms_follow_contents_specialized " PTR_FORMAT, p2i(obj));

   123     }

   124   )

   125   if (!oopDesc::is_null(heap_oop)) {

   126     oop referent = oopDesc::decode_heap_oop_not_null(heap_oop);

   127     if (!referent->is_gc_marked() &&

   128         MarkSweep::ref_processor()->discover_reference(obj, klass->reference_type())) {

   129       // reference was discovered, referent will be traversed later

   130       klass->InstanceKlass::oop_ms_follow_contents(obj);

   131       debug_only(

   132         if(TraceReferenceGC && PrintGCDetails) {

   133           gclog_or_tty->print_cr("       Non NULL enqueued " PTR_FORMAT, p2i(obj));

   134         }

   135       )

   136       return;

   137     } else {

   138       // treat referent as normal oop

   139       debug_only(

   140         if(TraceReferenceGC && PrintGCDetails) {

   141           gclog_or_tty->print_cr("       Non NULL normal " PTR_FORMAT, p2i(obj));

   142         }

   143       )

   144       MarkSweep::mark_and_push(referent_addr);

   145     }

   146   }

   147   T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj);

   148   // Treat discovered as normal oop, if ref is not "active",

   149   // i.e. if next is non-NULL.

   150   T  next_oop = oopDesc::load_heap_oop(next_addr);

   151   if (!oopDesc::is_null(next_oop)) { // i.e. ref is not "active"

   152     T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj);

   153     debug_only(

   154       if(TraceReferenceGC && PrintGCDetails) {

   155         gclog_or_tty->print_cr("   Process discovered as normal "

   156                                PTR_FORMAT, p2i(discovered_addr));

   157       }

   158     )

   159     MarkSweep::mark_and_push(discovered_addr);

   160   }

   161   // treat next as normal oop.  next is a link in the reference queue.

   162   debug_only(

   163     if(TraceReferenceGC && PrintGCDetails) {

   164       gclog_or_tty->print_cr("   Process next as normal " PTR_FORMAT, p2i(next_addr));

   165     }

   166   )

   167   MarkSweep::mark_and_push(next_addr);

   168   klass->InstanceKlass::oop_ms_follow_contents(obj);

   169 }

   170 

   171 void InstanceRefKlass::oop_ms_follow_contents(oop obj) {

   172   if (UseCompressedOops) {

   173     oop_ms_follow_contents_specialized<narrowOop>(this, obj);

   174   } else {

   175     oop_ms_follow_contents_specialized<oop>(this, obj);

   176   }

   177 }

   178 

   179 template <class T>

   180 static void oop_ms_follow_contents_specialized(oop obj, int index) {

   181   objArrayOop a = objArrayOop(obj);

   182   const size_t len = size_t(a->length());

   183   const size_t beg_index = size_t(index);

   184   assert(beg_index < len || len == 0, "index too large");

   185 

   186   const size_t stride = MIN2(len - beg_index, ObjArrayMarkingStride);

   187   const size_t end_index = beg_index + stride;

   188   T* const base = (T*)a->base();

   189   T* const beg = base + beg_index;

   190   T* const end = base + end_index;

   191 

   192   // Push the non-NULL elements of the next stride on the marking stack.

   193   for (T* e = beg; e < end; e++) {

   194     MarkSweep::mark_and_push<T>(e);

   195   }

   196 

   197   if (end_index < len) {

   198     MarkSweep::push_objarray(a, end_index); // Push the continuation.

   199   }

   200 }

   201 

   202 void ObjArrayKlass::oop_ms_follow_contents(oop obj) {

   203   assert (obj->is_array(), "obj must be array");

   204   MarkSweep::follow_klass(this);

   205   if (UseCompressedOops) {

   206     oop_ms_follow_contents_specialized<narrowOop>(obj, 0);

   207   } else {

   208     oop_ms_follow_contents_specialized<oop>(obj, 0);

   209   }

   210 }

   211 

   212 void TypeArrayKlass::oop_ms_follow_contents(oop obj) {

   213   assert(obj->is_typeArray(),"must be a type array");

   214   // Performance tweak: We skip iterating over the klass pointer since we

   215   // know that Universe::TypeArrayKlass never moves.

   216 }

   217 

   218 void MarkSweep::follow_array(objArrayOop array, int index) {

   219   if (UseCompressedOops) {

   220     oop_ms_follow_contents_specialized<narrowOop>(array, index);

   221   } else {

   222     oop_ms_follow_contents_specialized<oop>(array, index);

   223   }

   224 }

   225 

   226 void MarkSweep::follow_stack() {

   227   do {

   228     while (!_marking_stack.is_empty()) {

   229       oop obj = _marking_stack.pop();

   230       assert (obj->is_gc_marked(), "p must be marked");

   231       follow_object(obj);

   232     }

   233     // Process ObjArrays one at a time to avoid marking stack bloat.

   234     if (!_objarray_stack.is_empty()) {

   235       ObjArrayTask task = _objarray_stack.pop();

   236       follow_array(objArrayOop(task.obj()), task.index());

   237     }

   238   } while (!_marking_stack.is_empty() || !_objarray_stack.is_empty());

   239 }

   240 

   241 MarkSweep::FollowStackClosure MarkSweep::follow_stack_closure;

   242 

   243 void MarkSweep::FollowStackClosure::do_void() { follow_stack(); }

   244 

   245 void PreservedMark::adjust_pointer() {

   246   MarkSweep::adjust_pointer(&_obj);

   247 }

   248 

   249 void PreservedMark::restore() {

   250   _obj->set_mark(_mark);

   251 }

   252 

   253 // We preserve the mark which should be replaced at the end and the location

   254 // that it will go.  Note that the object that this markOop belongs to isn't

   255 // currently at that address but it will be after phase4

   256 void MarkSweep::preserve_mark(oop obj, markOop mark) {

   257   // We try to store preserved marks in the to space of the new generation since

   258   // this is storage which should be available.  Most of the time this should be

   259   // sufficient space for the marks we need to preserve but if it isn't we fall

   260   // back to using Stacks to keep track of the overflow.

   261   if (_preserved_count < _preserved_count_max) {

   262     _preserved_marks[_preserved_count++].init(obj, mark);

   263   } else {

   264     _preserved_mark_stack.push(mark);

   265     _preserved_oop_stack.push(obj);

   266   }

   267 }

   268 

   269 MarkSweep::AdjustPointerClosure MarkSweep::adjust_pointer_closure;

   270 

   271 template <typename T>

   272 void MarkSweep::AdjustPointerClosure::do_oop_nv(T* p)      { adjust_pointer(p); }

   273 void MarkSweep::AdjustPointerClosure::do_oop(oop* p)       { do_oop_nv(p); }

   274 void MarkSweep::AdjustPointerClosure::do_oop(narrowOop* p) { do_oop_nv(p); }

   275 

   276 void MarkSweep::adjust_marks() {

   277   assert( _preserved_oop_stack.size() == _preserved_mark_stack.size(),

   278          "inconsistent preserved oop stacks");

   279 

   280   // adjust the oops we saved earlier

   281   for (size_t i = 0; i < _preserved_count; i++) {

   282     _preserved_marks[i].adjust_pointer();

   283   }

   284 

   285   // deal with the overflow stack

   286   StackIterator<oop, mtGC> iter(_preserved_oop_stack);

   287   while (!iter.is_empty()) {

   288     oop* p = iter.next_addr();

   289     adjust_pointer(p);

   290   }

   291 }

   292 

   293 void MarkSweep::restore_marks() {

   294   assert(_preserved_oop_stack.size() == _preserved_mark_stack.size(),

   295          "inconsistent preserved oop stacks");

   296   if (PrintGC && Verbose) {

   297     gclog_or_tty->print_cr("Restoring " SIZE_FORMAT " marks",

   298                            _preserved_count + _preserved_oop_stack.size());

   299   }

   300 

   301   // restore the marks we saved earlier

   302   for (size_t i = 0; i < _preserved_count; i++) {

   303     _preserved_marks[i].restore();

   304   }

   305 

   306   // deal with the overflow

   307   while (!_preserved_oop_stack.is_empty()) {

   308     oop obj       = _preserved_oop_stack.pop();

   309     markOop mark  = _preserved_mark_stack.pop();

   310     obj->set_mark(mark);

   311   }

   312 }

   313 

   314 MarkSweep::IsAliveClosure   MarkSweep::is_alive;

   315 

   316 bool MarkSweep::IsAliveClosure::do_object_b(oop p) { return p->is_gc_marked(); }

   317 

   318 MarkSweep::KeepAliveClosure MarkSweep::keep_alive;

   319 

   320 void MarkSweep::KeepAliveClosure::do_oop(oop* p)       { MarkSweep::KeepAliveClosure::do_oop_work(p); }

   321 void MarkSweep::KeepAliveClosure::do_oop(narrowOop* p) { MarkSweep::KeepAliveClosure::do_oop_work(p); }

   322 

   323 void marksweep_init() {

   324   MarkSweep::_gc_timer = new (ResourceObj::C_HEAP, mtGC) STWGCTimer();

   325   MarkSweep::_gc_tracer = new (ResourceObj::C_HEAP, mtGC) SerialOldTracer();

   326 }

   327 

   328 int InstanceKlass::oop_ms_adjust_pointers(oop obj) {

   329   int size = size_helper();

   330   oop_oop_iterate_oop_maps<true>(obj, &MarkSweep::adjust_pointer_closure);

   331   return size;

   332 }

   333 

   334 int InstanceMirrorKlass::oop_ms_adjust_pointers(oop obj) {

   335   int size = oop_size(obj);

   336   InstanceKlass::oop_ms_adjust_pointers(obj);

   337 

   338   oop_oop_iterate_statics<true>(obj, &MarkSweep::adjust_pointer_closure);

   339   return size;

   340 }

   341 

   342 int InstanceClassLoaderKlass::oop_ms_adjust_pointers(oop obj) {

   343   return InstanceKlass::oop_ms_adjust_pointers(obj);

   344 }

   345 

   346 #ifdef ASSERT

   347 template <class T> static void trace_reference_gc(const char *s, oop obj,

   348                                                   T* referent_addr,

   349                                                   T* next_addr,

   350                                                   T* discovered_addr) {

   351   if(TraceReferenceGC && PrintGCDetails) {

   352     gclog_or_tty->print_cr("%s obj " PTR_FORMAT, s, p2i(obj));

   353     gclog_or_tty->print_cr("     referent_addr/* " PTR_FORMAT " / "

   354                            PTR_FORMAT, p2i(referent_addr),

   355                            p2i(referent_addr ?

   356                                (address)oopDesc::load_decode_heap_oop(referent_addr) : NULL));

   357     gclog_or_tty->print_cr("     next_addr/* " PTR_FORMAT " / "

   358                            PTR_FORMAT, p2i(next_addr),

   359                            p2i(next_addr ? (address)oopDesc::load_decode_heap_oop(next_addr) : NULL));

   360     gclog_or_tty->print_cr("     discovered_addr/* " PTR_FORMAT " / "

   361                            PTR_FORMAT, p2i(discovered_addr),

   362                            p2i(discovered_addr ?

   363                                (address)oopDesc::load_decode_heap_oop(discovered_addr) : NULL));

   364   }

   365 }

   366 #endif

   367 

   368 template <class T> void static adjust_object_specialized(oop obj) {

   369   T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);

   370   MarkSweep::adjust_pointer(referent_addr);

   371   T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj);

   372   MarkSweep::adjust_pointer(next_addr);

   373   T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj);

   374   MarkSweep::adjust_pointer(discovered_addr);

   375   debug_only(trace_reference_gc("InstanceRefKlass::oop_ms_adjust_pointers", obj,

   376                                 referent_addr, next_addr, discovered_addr);)

   377 }

   378 

   379 int InstanceRefKlass::oop_ms_adjust_pointers(oop obj) {

   380   int size = size_helper();

   381   InstanceKlass::oop_ms_adjust_pointers(obj);

   382 

   383   if (UseCompressedOops) {

   384     adjust_object_specialized<narrowOop>(obj);

   385   } else {

   386     adjust_object_specialized<oop>(obj);

   387   }

   388   return size;

   389 }

   390 

   391 int ObjArrayKlass::oop_ms_adjust_pointers(oop obj) {

   392   assert(obj->is_objArray(), "obj must be obj array");

   393   objArrayOop a = objArrayOop(obj);

   394   // Get size before changing pointers.

   395   // Don't call size() or oop_size() since that is a virtual call.

   396   int size = a->object_size();

   397   oop_oop_iterate_elements<true>(a, &MarkSweep::adjust_pointer_closure);

   398   return size;

   399 }

   400 

   401 int TypeArrayKlass::oop_ms_adjust_pointers(oop obj) {

   402   assert(obj->is_typeArray(), "must be a type array");

   403   typeArrayOop t = typeArrayOop(obj);

   404   // Performance tweak: We skip iterating over the klass pointer since we

   405   // know that Universe::TypeArrayKlass never moves.

   406   return t->object_size();

   407 }