1 /*
   2  * Copyright (c) 2017, 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 "code/codeCache.hpp"
  27 #include "gc/g1/g1CollectedHeap.hpp"
  28 #include "gc/g1/g1CollectorPolicy.hpp"
  29 #include "gc/g1/g1FullCollector.hpp"
  30 #include "gc/g1/g1FullGCAdjustTask.hpp"
  31 #include "gc/g1/g1FullGCCompactTask.hpp"
  32 #include "gc/g1/g1FullGCMarker.inline.hpp"
  33 #include "gc/g1/g1FullGCMarkTask.hpp"
  34 #include "gc/g1/g1FullGCPrepareTask.hpp"
  35 #include "gc/g1/g1FullGCReferenceProcessorExecutor.hpp"
  36 #include "gc/g1/g1FullGCScope.hpp"
  37 #include "gc/g1/g1OopClosures.hpp"
  38 #include "gc/g1/g1Policy.hpp"
  39 #include "gc/g1/g1StringDedup.hpp"
  40 #include "gc/shared/gcTraceTime.inline.hpp"
  41 #include "gc/shared/preservedMarks.hpp"
  42 #include "gc/shared/referenceProcessor.hpp"
  43 #include "gc/shared/weakProcessor.hpp"
  44 #include "logging/log.hpp"
  45 #include "runtime/biasedLocking.hpp"
  46 #include "runtime/handles.inline.hpp"
  47 #include "utilities/debug.hpp"
  48 
  49 static void clear_and_activate_derived_pointers() {
  50 #if COMPILER2_OR_JVMCI
  51   DerivedPointerTable::clear();
  52 #endif
  53 }
  54 
  55 static void deactivate_derived_pointers() {
  56 #if COMPILER2_OR_JVMCI
  57   DerivedPointerTable::set_active(false);
  58 #endif
  59 }
  60 
  61 static void update_derived_pointers() {
  62 #if COMPILER2_OR_JVMCI
  63   DerivedPointerTable::update_pointers();
  64 #endif
  65 }
  66 
  67 G1CMBitMap* G1FullCollector::mark_bitmap() {
  68   return _heap->concurrent_mark()->next_mark_bitmap();
  69 }
  70 
  71 ReferenceProcessor* G1FullCollector::reference_processor() {
  72   return _heap->ref_processor_stw();
  73 }
  74 
  75 G1FullCollector::G1FullCollector(G1CollectedHeap* heap, GCMemoryManager* memory_manager, bool explicit_gc, bool clear_soft_refs) :
  76     _heap(heap),
  77     _scope(memory_manager, explicit_gc, clear_soft_refs),
  78     _num_workers(heap->workers()->active_workers()),
  79     _oop_queue_set(_num_workers),
  80     _array_queue_set(_num_workers),
  81     _preserved_marks_set(true),
  82     _serial_compaction_point(),
  83     _is_alive(heap->concurrent_mark()->next_mark_bitmap()),
  84     _is_alive_mutator(heap->ref_processor_stw(), &_is_alive) {
  85   assert(SafepointSynchronize::is_at_safepoint(), "must be at a safepoint");
  86 
  87   _preserved_marks_set.init(_num_workers);
  88   _markers = NEW_C_HEAP_ARRAY(G1FullGCMarker*, _num_workers, mtGC);
  89   _compaction_points = NEW_C_HEAP_ARRAY(G1FullGCCompactionPoint*, _num_workers, mtGC);
  90   for (uint i = 0; i < _num_workers; i++) {
  91     _markers[i] = new G1FullGCMarker(i, _preserved_marks_set.get(i), mark_bitmap());
  92     _compaction_points[i] = new G1FullGCCompactionPoint();
  93     _oop_queue_set.register_queue(i, marker(i)->oop_stack());
  94     _array_queue_set.register_queue(i, marker(i)->objarray_stack());
  95   }
  96 }
  97 
  98 G1FullCollector::~G1FullCollector() {
  99   for (uint i = 0; i < _num_workers; i++) {
 100     delete _markers[i];
 101     delete _compaction_points[i];
 102   }
 103   FREE_C_HEAP_ARRAY(G1FullGCMarker*, _markers);
 104   FREE_C_HEAP_ARRAY(G1FullGCCompactionPoint*, _compaction_points);
 105 }
 106 
 107 void G1FullCollector::prepare_collection() {
 108   _heap->g1_policy()->record_full_collection_start();
 109 
 110   _heap->print_heap_before_gc();
 111   _heap->print_heap_regions();
 112 
 113   _heap->abort_concurrent_cycle();
 114   _heap->verify_before_full_collection(scope()->is_explicit_gc());
 115 
 116   _heap->gc_prologue(true);
 117   _heap->prepare_heap_for_full_collection();
 118 
 119   reference_processor()->enable_discovery();
 120   reference_processor()->setup_policy(scope()->should_clear_soft_refs());
 121 
 122   // When collecting the permanent generation Method*s may be moving,
 123   // so we either have to flush all bcp data or convert it into bci.
 124   CodeCache::gc_prologue();
 125 
 126   // We should save the marks of the currently locked biased monitors.
 127   // The marking doesn't preserve the marks of biased objects.
 128   BiasedLocking::preserve_marks();
 129 
 130   // Clear and activate derived pointer collection.
 131   clear_and_activate_derived_pointers();
 132 }
 133 
 134 void G1FullCollector::collect() {
 135   phase1_mark_live_objects();
 136   verify_after_marking();
 137 
 138   // Don't add any more derived pointers during later phases
 139   deactivate_derived_pointers();
 140 
 141   phase2_prepare_compaction();
 142 
 143   phase3_adjust_pointers();
 144 
 145   phase4_do_compaction();
 146 }
 147 
 148 void G1FullCollector::complete_collection() {
 149   // Restore all marks.
 150   restore_marks();
 151 
 152   // When the pointers have been adjusted and moved, we can
 153   // update the derived pointer table.
 154   update_derived_pointers();
 155 
 156   BiasedLocking::restore_marks();
 157   CodeCache::gc_epilogue();
 158   JvmtiExport::gc_epilogue();
 159 
 160   _heap->prepare_heap_for_mutators();
 161 
 162   _heap->g1_policy()->record_full_collection_end();
 163   _heap->gc_epilogue(true);
 164 
 165   _heap->verify_after_full_collection();
 166 
 167   _heap->print_heap_after_full_collection(scope()->heap_transition());
 168 }
 169 
 170 void G1FullCollector::phase1_mark_live_objects() {
 171   // Recursively traverse all live objects and mark them.
 172   GCTraceTime(Info, gc, phases) info("Phase 1: Mark live objects", scope()->timer());
 173 
 174   // Do the actual marking.
 175   G1FullGCMarkTask marking_task(this);
 176   run_task(&marking_task);
 177 
 178   // Process references discovered during marking.
 179   G1FullGCReferenceProcessingExecutor reference_processing(this);
 180   reference_processing.execute(scope()->timer(), scope()->tracer());
 181 
 182   // Weak oops cleanup.
 183   {
 184     GCTraceTime(Debug, gc, phases) trace("Phase 1: Weak Processing", scope()->timer());
 185     WeakProcessor::weak_oops_do(&_is_alive, &do_nothing_cl);
 186   }
 187 
 188   // Class unloading and cleanup.
 189   if (ClassUnloading) {
 190     GCTraceTime(Debug, gc, phases) debug("Phase 1: Class Unloading and Cleanup", scope()->timer());
 191     // Unload classes and purge the SystemDictionary.
 192     bool purged_class = SystemDictionary::do_unloading(&_is_alive, scope()->timer());
 193     _heap->complete_cleaning(&_is_alive, purged_class);
 194   } else {
 195     GCTraceTime(Debug, gc, phases) debug("Phase 1: String and Symbol Tables Cleanup", scope()->timer());
 196     // If no class unloading just clean out strings and symbols.
 197     _heap->partial_cleaning(&_is_alive, true, true, G1StringDedup::is_enabled());
 198   }
 199 
 200   scope()->tracer()->report_object_count_after_gc(&_is_alive);
 201 }
 202 
 203 void G1FullCollector::phase2_prepare_compaction() {
 204   GCTraceTime(Info, gc, phases) info("Phase 2: Prepare for compaction", scope()->timer());
 205   G1FullGCPrepareTask task(this);
 206   run_task(&task);
 207 
 208   // To avoid OOM when there is memory left.
 209   if (!task.has_freed_regions()) {
 210     task.prepare_serial_compaction();
 211   }
 212 }
 213 
 214 void G1FullCollector::phase3_adjust_pointers() {
 215   // Adjust the pointers to reflect the new locations
 216   GCTraceTime(Info, gc, phases) info("Phase 3: Adjust pointers and remembered sets", scope()->timer());
 217 
 218   G1FullGCAdjustTask task(this);
 219   run_task(&task);
 220 }
 221 
 222 void G1FullCollector::phase4_do_compaction() {
 223   // Compact the heap using the compaction queues created in phase 2.
 224   GCTraceTime(Info, gc, phases) info("Phase 4: Compact heap", scope()->timer());
 225   G1FullGCCompactTask task(this);
 226   run_task(&task);
 227 
 228   // Serial compact to avoid OOM when very few free regions.
 229   if (serial_compaction_point()->has_regions()) {
 230     task.serial_compaction();
 231   }
 232 }
 233 
 234 void G1FullCollector::restore_marks() {
 235   SharedRestorePreservedMarksTaskExecutor task_executor(_heap->workers());
 236   _preserved_marks_set.restore(&task_executor);
 237   _preserved_marks_set.reclaim();
 238 }
 239 
 240 void G1FullCollector::run_task(AbstractGangTask* task) {
 241   _heap->workers()->run_task(task, _num_workers);
 242 }
 243 
 244 void G1FullCollector::verify_after_marking() {
 245   if (!VerifyDuringGC || !_heap->verifier()->should_verify(G1HeapVerifier::G1VerifyFull)) {
 246     // Only do verification if VerifyDuringGC and G1VerifyFull is set.
 247     return;
 248   }
 249 
 250   HandleMark hm;  // handle scope
 251 #if COMPILER2_OR_JVMCI
 252   DerivedPointerTableDeactivate dpt_deact;
 253 #endif
 254   _heap->prepare_for_verify();
 255   // Note: we can verify only the heap here. When an object is
 256   // marked, the previous value of the mark word (including
 257   // identity hash values, ages, etc) is preserved, and the mark
 258   // word is set to markOop::marked_value - effectively removing
 259   // any hash values from the mark word. These hash values are
 260   // used when verifying the dictionaries and so removing them
 261   // from the mark word can make verification of the dictionaries
 262   // fail. At the end of the GC, the original mark word values
 263   // (including hash values) are restored to the appropriate
 264   // objects.
 265   GCTraceTime(Info, gc, verify)("Verifying During GC (full)");
 266   _heap->verify(VerifyOption_G1UseFullMarking);
 267 }