1 /*
   2  * Copyright (c) 2015, 2018, Red Hat, Inc. All rights reserved.
   3  *
   4  * This code is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License version 2 only, as
   6  * published by the Free Software Foundation.
   7  *
   8  * This code is distributed in the hope that it will be useful, but WITHOUT
   9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  11  * version 2 for more details (a copy is included in the LICENSE file that
  12  * accompanied this code).
  13  *
  14  * You should have received a copy of the GNU General Public License version
  15  * 2 along with this work; if not, write to the Free Software Foundation,
  16  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  17  *
  18  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  19  * or visit www.oracle.com if you need additional information or have any
  20  * questions.
  21  *
  22  */
  23 
  24 #include "precompiled.hpp"
  25 
  26 #include "classfile/classLoaderData.hpp"
  27 #include "classfile/systemDictionary.hpp"
  28 #include "code/codeCache.hpp"
  29 #include "gc_implementation/shenandoah/shenandoahClosures.inline.hpp"
  30 #include "gc_implementation/shenandoah/shenandoahRootProcessor.inline.hpp"
  31 #include "gc_implementation/shenandoah/shenandoahHeap.inline.hpp"
  32 #include "gc_implementation/shenandoah/shenandoahFreeSet.hpp"
  33 #include "gc_implementation/shenandoah/shenandoahCollectorPolicy.hpp"
  34 #include "gc_implementation/shenandoah/shenandoahPhaseTimings.hpp"
  35 #include "gc_implementation/shenandoah/shenandoahStringDedup.hpp"
  36 #include "gc_implementation/shenandoah/shenandoahSynchronizerIterator.hpp"
  37 #include "gc_implementation/shenandoah/shenandoahWorkGroup.hpp"
  38 #include "memory/allocation.inline.hpp"
  39 #include "memory/resourceArea.hpp"
  40 #include "runtime/fprofiler.hpp"
  41 #include "runtime/thread.hpp"
  42 #include "services/management.hpp"
  43 
  44 #if INCLUDE_JFR
  45 #include "jfr/leakprofiler/leakProfiler.hpp"
  46 #endif
  47 
  48 ShenandoahSerialRoot::ShenandoahSerialRoot(ShenandoahSerialRoot::OopsDo oops_do, ShenandoahPhaseTimings::Phase phase, ShenandoahPhaseTimings::ParPhase par_phase) :
  49   _claimed(0), _oops_do(oops_do), _phase(phase), _par_phase(par_phase) {
  50 }
  51 
  52 void ShenandoahSerialRoot::oops_do(OopClosure* cl, uint worker_id) {
  53   if (_claimed == 0 && Atomic::cmpxchg(1, &_claimed, 0) == 0) {
  54     ShenandoahWorkerTimingsTracker timer(_phase, _par_phase, worker_id);
  55     _oops_do(cl);
  56   }
  57 }
  58 
  59 static void universe_oops_do(OopClosure* closure) {
  60   Universe::oops_do(closure);
  61 }
  62 
  63 ShenandoahSerialRoots::ShenandoahSerialRoots(ShenandoahPhaseTimings::Phase phase) :
  64   _phase(phase),
  65   _universe_roots(&universe_oops_do, phase, ShenandoahPhaseTimings::UniverseRoots),
  66   _management_roots(&Management::oops_do, phase, ShenandoahPhaseTimings::ManagementRoots),
  67   _jvmti_roots(&JvmtiExport::oops_do, phase, ShenandoahPhaseTimings::JVMTIRoots),
  68   _jni_handle_roots(&JNIHandles::oops_do, phase, ShenandoahPhaseTimings::JNIRoots),
  69   _flat_profiler_roots(&FlatProfiler::oops_do, phase, ShenandoahPhaseTimings::FlatProfilerRoots) {
  70 }
  71 
  72 void ShenandoahSerialRoots::oops_do(OopClosure* cl, uint worker_id) {
  73   _universe_roots.oops_do(cl, worker_id);
  74   _management_roots.oops_do(cl, worker_id);
  75   _jvmti_roots.oops_do(cl, worker_id);
  76   _jni_handle_roots.oops_do(cl, worker_id);
  77   _flat_profiler_roots.oops_do(cl, worker_id);
  78 
  79   {
  80     ShenandoahWorkerTimingsTracker timer(_phase, ShenandoahPhaseTimings::ObjectSynchronizerRoots, worker_id);
  81     while(_om_iterator.parallel_oops_do(cl));
  82   }
  83 }
  84 
  85 ShenandoahSystemDictionaryRoots::ShenandoahSystemDictionaryRoots(ShenandoahPhaseTimings::Phase phase) :
  86   _phase(phase), _claimed(0) {
  87 }
  88 
  89 void ShenandoahSystemDictionaryRoots::strong_oops_do(OopClosure* oops, uint worker_id) {
  90   if (_claimed == 0 && Atomic::cmpxchg(1, &_claimed, 0) == 0) {
  91     ShenandoahWorkerTimingsTracker timer(_phase, ShenandoahPhaseTimings::SystemDictionaryRoots, worker_id);
  92     SystemDictionary::roots_oops_do(oops, NULL);
  93   }
  94 }
  95 
  96 void ShenandoahSystemDictionaryRoots::oops_do(OopClosure* oops, uint worker_id) {
  97   if (_claimed == 0 && Atomic::cmpxchg(1, &_claimed, 0) == 0) {
  98     ShenandoahWorkerTimingsTracker timer(_phase, ShenandoahPhaseTimings::SystemDictionaryRoots, worker_id);
  99     SystemDictionary::roots_oops_do(oops, oops);
 100   }
 101 }
 102 
 103 ShenandoahStringTableRoots::ShenandoahStringTableRoots(ShenandoahPhaseTimings::Phase phase) :
 104   _phase(phase)
 105 {}
 106 
 107 void ShenandoahStringTableRoots::oops_do(OopClosure* oops, uint worker_id) {
 108   ShenandoahWorkerTimingsTracker timer(_phase, ShenandoahPhaseTimings::StringTableRoots, worker_id);
 109   StringTable::possibly_parallel_oops_do_shenandoah(oops);
 110 }
 111 
 112 ShenandoahThreadRoots::ShenandoahThreadRoots(ShenandoahPhaseTimings::Phase phase) :
 113   _phase(phase) {
 114   ShenandoahHeap* const heap = ShenandoahHeap::heap();
 115   heap->set_par_threads(heap->workers()->active_workers());
 116 }
 117 
 118 void ShenandoahThreadRoots::oops_do(OopClosure* oops_cl, CLDClosure* cld_cl, CodeBlobClosure* code_cl, uint worker_id) {
 119   ShenandoahWorkerTimingsTracker timer(_phase, ShenandoahPhaseTimings::ThreadRoots, worker_id);
 120   ResourceMark rm;
 121   Threads::possibly_parallel_oops_do(oops_cl, cld_cl, code_cl);
 122 }
 123 
 124 ShenandoahWeakRoot::ShenandoahWeakRoot(ShenandoahPhaseTimings::Phase phase, ShenandoahPhaseTimings::ParPhase par_phase, ShenandoahWeakRoot::WeakOopsDo oops_do) :
 125   _phase(phase), _par_phase(par_phase), _claimed(0), _weak_oops_do(oops_do) {
 126 }
 127 
 128 void ShenandoahWeakRoot::oops_do(OopClosure* keep_alive, uint worker_id) {
 129   AlwaysTrueClosure always_true;
 130   weak_oops_do(&always_true, keep_alive, worker_id);
 131 }
 132 
 133 void ShenandoahWeakRoot::weak_oops_do(BoolObjectClosure* is_alive, OopClosure* keep_alive, uint worker_id) {
 134   if (_claimed == 0 && Atomic::cmpxchg(1, &_claimed, 0) == 0) {
 135     ShenandoahWorkerTimingsTracker t(_phase, _par_phase, worker_id);
 136     _weak_oops_do(is_alive, keep_alive);
 137   }
 138 }
 139 
 140 ShenandoahWeakRoots::ShenandoahWeakRoots(ShenandoahPhaseTimings::Phase phase) :
 141 #if INCLUDE_JFR
 142   _jfr_weak_roots(phase, ShenandoahPhaseTimings::JFRWeakRoots, &LeakProfiler::oops_do),
 143 #endif // INCLUDE_JFR
 144   _jni_weak_roots(phase, ShenandoahPhaseTimings::JNIWeakRoots, &JNIHandles::weak_oops_do) {
 145 }
 146 
 147 void ShenandoahWeakRoots::oops_do(OopClosure* keep_alive, uint worker_id) {
 148   JFR_ONLY(_jfr_weak_roots.oops_do(keep_alive, worker_id);)
 149   _jni_weak_roots.oops_do(keep_alive, worker_id);
 150 }
 151 
 152 void ShenandoahWeakRoots::weak_oops_do(BoolObjectClosure* is_alive, OopClosure* keep_alive, uint worker_id) {
 153   JFR_ONLY(_jfr_weak_roots.weak_oops_do(is_alive, keep_alive, worker_id);)
 154   _jni_weak_roots.weak_oops_do(is_alive, keep_alive, worker_id);
 155 }
 156 
 157 ShenandoahStringDedupRoots::ShenandoahStringDedupRoots(ShenandoahPhaseTimings::Phase phase) : _phase(phase) {
 158   if (ShenandoahStringDedup::is_enabled()) {
 159     ShenandoahStringDedup::clear_claimed();
 160   }
 161 }
 162 
 163 void ShenandoahStringDedupRoots::oops_do(OopClosure* oops, uint worker_id) {
 164   if (ShenandoahStringDedup::is_enabled()) {
 165     ShenandoahStringDedup::parallel_oops_do(_phase, oops, worker_id);
 166   }
 167 }
 168 
 169 ShenandoahClassLoaderDataRoots::ShenandoahClassLoaderDataRoots(ShenandoahPhaseTimings::Phase phase) :
 170   _phase(phase) {
 171   ClassLoaderDataGraph::clear_claimed_marks();
 172 }
 173 
 174 void ShenandoahClassLoaderDataRoots::cld_do(CLDClosure* clds, uint worker_id) {
 175   ShenandoahWorkerTimingsTracker timer(_phase, ShenandoahPhaseTimings::CLDGRoots, worker_id);
 176   ClassLoaderDataGraph::roots_cld_do(clds, clds);
 177 }
 178 
 179 void ShenandoahClassLoaderDataRoots::always_strong_cld_do(CLDClosure* clds, uint worker_id) {
 180   ShenandoahWorkerTimingsTracker timer(_phase, ShenandoahPhaseTimings::CLDGRoots, worker_id);
 181   ClassLoaderDataGraph::always_strong_cld_do(clds);
 182 }
 183 
 184 ShenandoahRootProcessor::ShenandoahRootProcessor(ShenandoahPhaseTimings::Phase phase) :
 185   _srs(ShenandoahHeap::heap()),
 186   _heap(ShenandoahHeap::heap()),
 187   _phase(phase) {
 188   assert(SafepointSynchronize::is_at_safepoint(), "Must at safepoint");
 189   _heap->phase_timings()->record_workers_start(_phase);
 190 }
 191 
 192 ShenandoahRootProcessor::~ShenandoahRootProcessor() {
 193   assert(SafepointSynchronize::is_at_safepoint(), "Must at safepoint");
 194   _heap->phase_timings()->record_workers_end(_phase);
 195 }
 196 
 197 ShenandoahRootEvacuator::ShenandoahRootEvacuator(ShenandoahPhaseTimings::Phase phase) :
 198   ShenandoahRootProcessor(phase),
 199   _serial_roots(phase),
 200   _dict_roots(phase),
 201   _cld_roots(phase),
 202   _thread_roots(phase),
 203   _weak_roots(phase),
 204   _dedup_roots(phase),
 205   _string_table_roots(phase),
 206   _code_roots(phase)
 207 {}
 208 
 209 ShenandoahHeapIterationRootScanner::ShenandoahHeapIterationRootScanner() :
 210   ShenandoahRootProcessor(ShenandoahPhaseTimings::heap_iteration_roots),
 211   _serial_roots(ShenandoahPhaseTimings::heap_iteration_roots),
 212   _dict_roots(ShenandoahPhaseTimings::heap_iteration_roots),
 213   _thread_roots(ShenandoahPhaseTimings::heap_iteration_roots),
 214   _cld_roots(ShenandoahPhaseTimings::heap_iteration_roots),
 215   _weak_roots(ShenandoahPhaseTimings::heap_iteration_roots),
 216   _dedup_roots(ShenandoahPhaseTimings::heap_iteration_roots),
 217   _string_table_roots(ShenandoahPhaseTimings::heap_iteration_roots),
 218   _code_roots(ShenandoahPhaseTimings::heap_iteration_roots)
 219 {}
 220 
 221  void ShenandoahHeapIterationRootScanner::roots_do(OopClosure* oops) {
 222    assert(Thread::current()->is_VM_thread(), "Only by VM thread");
 223    // Must use _claim_none to avoid interfering with concurrent CLDG iteration
 224    CLDToOopClosure clds(oops, false /* must claim */);
 225    MarkingCodeBlobClosure code(oops, !CodeBlobToOopClosure::FixRelocations);
 226    ResourceMark rm;
 227 
 228    _serial_roots.oops_do(oops, 0);
 229    _dict_roots.oops_do(oops, 0);
 230    _cld_roots.cld_do(&clds, 0);
 231    _thread_roots.oops_do(oops, NULL, NULL, 0);
 232    _code_roots.code_blobs_do(&code, 0);
 233 
 234    _weak_roots.oops_do(oops, 0);
 235    _string_table_roots.oops_do(oops, 0);
 236    _dedup_roots.oops_do(oops, 0);
 237  }
 238 
 239 void ShenandoahRootEvacuator::roots_do(uint worker_id, OopClosure* oops) {
 240   {
 241     // Evacuate the PLL here so that the SurrogateLockerThread doesn't
 242     // have to. SurrogateLockerThread can execute write barrier in VMOperation
 243     // prolog. If the SLT runs into OOM during that evacuation, the VMOperation
 244     // may deadlock. Doing this evacuation the first thing makes that critical
 245     // OOM less likely to happen.  It is a bit excessive to perform WB by all
 246     // threads, but this guarantees the very first evacuation would be the PLL.
 247     //
 248     // This pre-evac can still silently fail with OOME here, and PLL would not
 249     // get evacuated. This would mean next VMOperation would try to evac PLL in
 250     // SLT thread. We make additional effort to recover from that OOME in SLT,
 251     // see ShenandoahHeap::oom_during_evacuation(). It seems to be the lesser evil
 252     // to do there, because we cannot trigger Full GC right here, when we are
 253     // in another VMOperation.
 254 
 255     ShenandoahHeap* const heap = ShenandoahHeap::heap();
 256     assert(heap->is_evacuation_in_progress(), "only when evacuating");
 257     HeapWord* pll_addr = java_lang_ref_Reference::pending_list_lock_addr();
 258     oop pll;
 259     if (UseCompressedOops) {
 260       pll = oopDesc::load_decode_heap_oop((narrowOop *)pll_addr);
 261     } else {
 262       pll = oopDesc::load_decode_heap_oop((oop*)pll_addr);
 263     }
 264     if (!oopDesc::is_null(pll) && heap->in_collection_set(pll)) {
 265       oop fwd = ShenandoahBarrierSet::resolve_forwarded_not_null(pll);
 266       if (pll == fwd) {
 267         Thread *t = Thread::current();
 268         heap->evacuate_object(pll, t);
 269       }
 270     }
 271   }
 272 
 273   MarkingCodeBlobClosure blobsCl(oops, CodeBlobToOopClosure::FixRelocations);
 274   CLDToOopClosure clds(oops);
 275 
 276   _serial_roots.oops_do(oops, worker_id);
 277   _dict_roots.oops_do(oops, worker_id);
 278   _thread_roots.oops_do(oops, NULL, NULL, worker_id);
 279   _cld_roots.cld_do(&clds, worker_id);
 280   _code_roots.code_blobs_do(&blobsCl, worker_id);
 281 
 282   _weak_roots.oops_do(oops, worker_id);
 283   _dedup_roots.oops_do(oops, worker_id);
 284   _string_table_roots.oops_do(oops, worker_id);
 285 }
 286 
 287 ShenandoahRootUpdater::ShenandoahRootUpdater(ShenandoahPhaseTimings::Phase phase) :
 288   ShenandoahRootProcessor(phase),
 289   _serial_roots(phase),
 290   _dict_roots(phase),
 291   _cld_roots(phase),
 292   _thread_roots(phase),
 293   _weak_roots(phase),
 294   _dedup_roots(phase),
 295   _string_table_roots(phase),
 296   _code_roots(phase)
 297 {}
 298 
 299 void ShenandoahRootUpdater::roots_do(uint worker_id, BoolObjectClosure* is_alive, OopClosure* keep_alive) {
 300   CodeBlobToOopClosure update_blobs(keep_alive, CodeBlobToOopClosure::FixRelocations);
 301   CLDToOopClosure clds(keep_alive);
 302 
 303   _serial_roots.oops_do(keep_alive, worker_id);
 304   _dict_roots.oops_do(keep_alive, worker_id);
 305   _thread_roots.oops_do(keep_alive, &clds, NULL, worker_id);
 306   _cld_roots.cld_do(&clds, worker_id);
 307 
 308   _code_roots.code_blobs_do(&update_blobs, worker_id);
 309 
 310   _weak_roots.weak_oops_do(is_alive, keep_alive, worker_id);
 311   _dedup_roots.oops_do(keep_alive, worker_id);
 312   _string_table_roots.oops_do(keep_alive, worker_id);
 313 }
 314 
 315 
 316 ShenandoahRootAdjuster::ShenandoahRootAdjuster(ShenandoahPhaseTimings::Phase phase) :
 317   ShenandoahRootProcessor(phase),
 318   _serial_roots(phase),
 319   _dict_roots(phase),
 320   _cld_roots(phase),
 321   _thread_roots(phase),
 322   _weak_roots(phase),
 323   _dedup_roots(phase),
 324   _string_table_roots(phase),
 325   _code_roots(phase)
 326 {
 327   assert(ShenandoahHeap::heap()->is_full_gc_in_progress(), "Full GC only");
 328 }
 329 
 330 void ShenandoahRootAdjuster::roots_do(uint worker_id, OopClosure* oops) {
 331   CodeBlobToOopClosure adjust_code_closure(oops, CodeBlobToOopClosure::FixRelocations);
 332   CLDToOopClosure adjust_cld_closure(oops);
 333 
 334   _serial_roots.oops_do(oops, worker_id);
 335   _dict_roots.oops_do(oops, worker_id);
 336   _thread_roots.oops_do(oops, NULL, NULL, worker_id);
 337   _cld_roots.always_strong_cld_do(&adjust_cld_closure, worker_id);
 338   _code_roots.code_blobs_do(&adjust_code_closure, worker_id);
 339 
 340   _weak_roots.oops_do(oops, worker_id);
 341   _dedup_roots.oops_do(oops, worker_id);
 342   _string_table_roots.oops_do(oops, worker_id);
 343 }