1  /*
   2  * Copyright (c) 2001, 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 "gc/g1/concurrentMarkThread.inline.hpp"
  27 #include "gc/g1/g1CollectedHeap.inline.hpp"
  28 #include "gc/g1/g1CollectorPolicy.hpp"
  29 #include "gc/g1/g1Log.hpp"
  30 #include "gc/g1/g1MMUTracker.hpp"
  31 #include "gc/g1/suspendibleThreadSet.hpp"
  32 #include "gc/g1/vm_operations_g1.hpp"
  33 #include "gc/shared/gcId.hpp"
  34 #include "gc/shared/gcTrace.hpp"


  35 #include "memory/resourceArea.hpp"
  36 #include "runtime/vmThread.hpp"
  37 
  38 // ======= Concurrent Mark Thread ========
  39 
  40 // The CM thread is created when the G1 garbage collector is used
  41 
  42 SurrogateLockerThread*
  43      ConcurrentMarkThread::_slt = NULL;
  44 
  45 ConcurrentMarkThread::ConcurrentMarkThread(ConcurrentMark* cm) :
  46   ConcurrentGCThread(),
  47   _cm(cm),
  48   _state(Idle),
  49   _vtime_accum(0.0),
  50   _vtime_mark_accum(0.0) {
  51 
  52   set_name("G1 Main Marker");
  53   create_and_start();
  54 }
  55 
  56 class CMCheckpointRootsFinalClosure: public VoidClosure {
  57 
  58   ConcurrentMark* _cm;
  59 public:
  60 
  61   CMCheckpointRootsFinalClosure(ConcurrentMark* cm) :
  62     _cm(cm) {}
  63 
  64   void do_void(){
  65     _cm->checkpointRootsFinal(false); // !clear_all_soft_refs
  66   }
  67 };
  68 
  69 class CMCleanUp: public VoidClosure {
  70   ConcurrentMark* _cm;
  71 public:
  72 
  73   CMCleanUp(ConcurrentMark* cm) :
  74     _cm(cm) {}
  75 
  76   void do_void(){
  77     _cm->cleanup();
  78   }
  79 };
  80 
  81 // We want to avoid that the logging from the concurrent thread is mixed
  82 // with the logging from a STW GC. So, if necessary join the STS to ensure
  83 // that the logging is done either before or after the STW logging.
  84 void ConcurrentMarkThread::cm_log(bool doit, bool join_sts, const char* fmt, ...) {
  85   if (doit) {
  86     SuspendibleThreadSetJoiner sts_joiner(join_sts);
  87     va_list args;
  88     va_start(args, fmt);
  89     gclog_or_tty->gclog_stamp();
  90     gclog_or_tty->vprint_cr(fmt, args);
  91     va_end(args);
  92   }
  93 }
  94 
  95 // Marking pauses can be scheduled flexibly, so we might delay marking to meet MMU.
  96 void ConcurrentMarkThread::delay_to_keep_mmu(G1CollectorPolicy* g1_policy, bool remark) {
  97   if (g1_policy->adaptive_young_list_length()) {
  98     double now = os::elapsedTime();
  99     double prediction_ms = remark ? g1_policy->predict_remark_time_ms()
 100                                   : g1_policy->predict_cleanup_time_ms();
 101     G1MMUTracker *mmu_tracker = g1_policy->mmu_tracker();
 102     jlong sleep_time_ms = mmu_tracker->when_ms(now, prediction_ms);
 103     os::sleep(this, sleep_time_ms, false);
 104   }
 105 }
 106 void ConcurrentMarkThread::run() {
 107   initialize_in_thread();
 108   wait_for_universe_init();
 109 
 110   run_service();
 111 
 112   terminate();
 113 }
 114 
 115 void ConcurrentMarkThread::run_service() {
 116   _vtime_start = os::elapsedVTime();
 117 
 118   G1CollectedHeap* g1h = G1CollectedHeap::heap();
 119   G1CollectorPolicy* g1_policy = g1h->g1_policy();
 120 
 121   while (!_should_terminate) {
 122     // wait until started is set.
 123     sleepBeforeNextCycle();
 124     if (_should_terminate) {
 125       break;
 126     }
 127 
 128     assert(GCId::current() != GCId::undefined(), "GC id should have been set up by the initial mark GC.");
 129     {
 130       ResourceMark rm;
 131       HandleMark   hm;
 132       double cycle_start = os::elapsedVTime();
 133 
 134       // We have to ensure that we finish scanning the root regions
 135       // before the next GC takes place. To ensure this we have to
 136       // make sure that we do not join the STS until the root regions
 137       // have been scanned. If we did then it's possible that a
 138       // subsequent GC could block us from joining the STS and proceed
 139       // without the root regions have been scanned which would be a
 140       // correctness issue.
 141 
 142       if (!cm()->has_aborted()) {
 143         _cm->scanRootRegions();
 144       }
 145 
 146       double mark_start_sec = os::elapsedTime();
 147       cm_log(G1Log::fine(), true, "[GC concurrent-mark-start]");



 148 
 149       int iter = 0;
 150       do {
 151         iter++;
 152         if (!cm()->has_aborted()) {
 153           _cm->markFromRoots();
 154         }
 155 
 156         double mark_end_time = os::elapsedVTime();
 157         double mark_end_sec = os::elapsedTime();
 158         _vtime_mark_accum += (mark_end_time - cycle_start);
 159         if (!cm()->has_aborted()) {
 160           delay_to_keep_mmu(g1_policy, true /* remark */);
 161 
 162           cm_log(G1Log::fine(), true, "[GC concurrent-mark-end, %1.7lf secs]", mark_end_sec - mark_start_sec);


 163 
 164           CMCheckpointRootsFinalClosure final_cl(_cm);
 165           VM_CGC_Operation op(&final_cl, "GC remark", true /* needs_pll */);
 166           VMThread::execute(&op);
 167         }
 168         if (cm()->restart_for_overflow()) {
 169           cm_log(G1TraceMarkStackOverflow, true, "Restarting conc marking because of MS overflow in remark (restart #%d).", iter);
 170           cm_log(G1Log::fine(), true, "[GC concurrent-mark-restart-for-overflow]");
 171         }
 172       } while (cm()->restart_for_overflow());
 173 
 174       double end_time = os::elapsedVTime();
 175       // Update the total virtual time before doing this, since it will try
 176       // to measure it to get the vtime for this marking.  We purposely
 177       // neglect the presumably-short "completeCleanup" phase here.
 178       _vtime_accum = (end_time - _vtime_start);
 179 
 180       if (!cm()->has_aborted()) {
 181         delay_to_keep_mmu(g1_policy, false /* cleanup */);
 182 
 183         CMCleanUp cl_cl(_cm);
 184         VM_CGC_Operation op(&cl_cl, "GC cleanup", false /* needs_pll */);
 185         VMThread::execute(&op);
 186       } else {
 187         // We don't want to update the marking status if a GC pause
 188         // is already underway.
 189         SuspendibleThreadSetJoiner sts_join;
 190         g1h->collector_state()->set_mark_in_progress(false);
 191       }
 192 
 193       // Check if cleanup set the free_regions_coming flag. If it
 194       // hasn't, we can just skip the next step.
 195       if (g1h->free_regions_coming()) {
 196         // The following will finish freeing up any regions that we
 197         // found to be empty during cleanup. We'll do this part
 198         // without joining the suspendible set. If an evacuation pause
 199         // takes place, then we would carry on freeing regions in
 200         // case they are needed by the pause. If a Full GC takes
 201         // place, it would wait for us to process the regions
 202         // reclaimed by cleanup.
 203 
 204         double cleanup_start_sec = os::elapsedTime();
 205         cm_log(G1Log::fine(), false, "[GC concurrent-cleanup-start]");
 206 
 207         // Now do the concurrent cleanup operation.
 208         _cm->completeCleanup();
 209 
 210         // Notify anyone who's waiting that there are no more free
 211         // regions coming. We have to do this before we join the STS
 212         // (in fact, we should not attempt to join the STS in the
 213         // interval between finishing the cleanup pause and clearing
 214         // the free_regions_coming flag) otherwise we might deadlock:
 215         // a GC worker could be blocked waiting for the notification
 216         // whereas this thread will be blocked for the pause to finish
 217         // while it's trying to join the STS, which is conditional on
 218         // the GC workers finishing.
 219         g1h->reset_free_regions_coming();
 220 
 221         double cleanup_end_sec = os::elapsedTime();
 222         cm_log(G1Log::fine(), true, "[GC concurrent-cleanup-end, %1.7lf secs]", cleanup_end_sec - cleanup_start_sec);
 223       }
 224       guarantee(cm()->cleanup_list_is_empty(),
 225                 "at this point there should be no regions on the cleanup list");
 226 
 227       // There is a tricky race before recording that the concurrent
 228       // cleanup has completed and a potential Full GC starting around
 229       // the same time. We want to make sure that the Full GC calls
 230       // abort() on concurrent mark after
 231       // record_concurrent_mark_cleanup_completed(), since abort() is
 232       // the method that will reset the concurrent mark state. If we
 233       // end up calling record_concurrent_mark_cleanup_completed()
 234       // after abort() then we might incorrectly undo some of the work
 235       // abort() did. Checking the has_aborted() flag after joining
 236       // the STS allows the correct ordering of the two methods. There
 237       // are two scenarios:
 238       //
 239       // a) If we reach here before the Full GC, the fact that we have
 240       // joined the STS means that the Full GC cannot start until we
 241       // leave the STS, so record_concurrent_mark_cleanup_completed()
 242       // will complete before abort() is called.
 243       //
 244       // b) If we reach here during the Full GC, we'll be held up from
 245       // joining the STS until the Full GC is done, which means that
 246       // abort() will have completed and has_aborted() will return
 247       // true to prevent us from calling
 248       // record_concurrent_mark_cleanup_completed() (and, in fact, it's
 249       // not needed any more as the concurrent mark state has been
 250       // already reset).
 251       {
 252         SuspendibleThreadSetJoiner sts_join;
 253         if (!cm()->has_aborted()) {
 254           g1_policy->record_concurrent_mark_cleanup_completed();
 255         } else {
 256           cm_log(G1Log::fine(), false, "[GC concurrent-mark-abort]");
 257         }
 258       }
 259 
 260       // We now want to allow clearing of the marking bitmap to be
 261       // suspended by a collection pause.
 262       // We may have aborted just before the remark. Do not bother clearing the
 263       // bitmap then, as it has been done during mark abort.
 264       if (!cm()->has_aborted()) {
 265         _cm->clearNextBitmap();
 266       } else {
 267         assert(!G1VerifyBitmaps || _cm->nextMarkBitmapIsClear(), "Next mark bitmap must be clear");
 268       }
 269     }
 270 
 271     // Update the number of full collections that have been
 272     // completed. This will also notify the FullGCCount_lock in case a
 273     // Java thread is waiting for a full GC to happen (e.g., it
 274     // called System.gc() with +ExplicitGCInvokesConcurrent).
 275     {
 276       SuspendibleThreadSetJoiner sts_join;
 277       g1h->increment_old_marking_cycles_completed(true /* concurrent */);
 278       g1h->register_concurrent_cycle_end();
 279     }
 280   }
 281 }
 282 
 283 void ConcurrentMarkThread::stop() {
 284   {
 285     MutexLockerEx ml(Terminator_lock);
 286     _should_terminate = true;
 287   }
 288 
 289   stop_service();
 290 
 291   {
 292     MutexLockerEx ml(Terminator_lock);
 293     while (!_has_terminated) {
 294       Terminator_lock->wait();
 295     }
 296   }
 297 }
 298 
 299 void ConcurrentMarkThread::stop_service() {
 300   MutexLockerEx ml(CGC_lock, Mutex::_no_safepoint_check_flag);
 301   CGC_lock->notify_all();
 302 }
 303 
 304 void ConcurrentMarkThread::sleepBeforeNextCycle() {
 305   // We join here because we don't want to do the "shouldConcurrentMark()"
 306   // below while the world is otherwise stopped.
 307   assert(!in_progress(), "should have been cleared");
 308 
 309   MutexLockerEx x(CGC_lock, Mutex::_no_safepoint_check_flag);
 310   while (!started() && !_should_terminate) {
 311     CGC_lock->wait(Mutex::_no_safepoint_check_flag);
 312   }
 313 
 314   if (started()) {
 315     set_in_progress();
 316   }
 317 }
 318 
 319 // Note: As is the case with CMS - this method, although exported
 320 // by the ConcurrentMarkThread, which is a non-JavaThread, can only
 321 // be called by a JavaThread. Currently this is done at vm creation
 322 // time (post-vm-init) by the main/Primordial (Java)Thread.
 323 // XXX Consider changing this in the future to allow the CM thread
 324 // itself to create this thread?
 325 void ConcurrentMarkThread::makeSurrogateLockerThread(TRAPS) {
 326   assert(UseG1GC, "SLT thread needed only for concurrent GC");
 327   assert(THREAD->is_Java_thread(), "must be a Java thread");
 328   assert(_slt == NULL, "SLT already created");
 329   _slt = SurrogateLockerThread::make(THREAD);
 330 }
--- EOF ---