1 /*

     2  * Copyright 2001-2007 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    20  * CA 95054 USA or visit www.sun.com if you need additional information or

    21  * have any questions.

    22  *

    23  */

    24 

    25 #include "incls/_precompiled.incl"

    26 #include "incls/_concurrentMarkThread.cpp.incl"

    27 

    28 // ======= Concurrent Mark Thread ========

    29 

    30 // The CM thread is created when the G1 garbage collector is used

    31 

    32 SurrogateLockerThread*

    33      ConcurrentMarkThread::_slt = NULL;

    34 

    35 ConcurrentMarkThread::ConcurrentMarkThread(ConcurrentMark* cm) :

    36   ConcurrentGCThread(),

    37   _cm(cm),

    38   _started(false),

    39   _in_progress(false),

    40   _vtime_accum(0.0),

    41   _vtime_mark_accum(0.0),

    42   _vtime_count_accum(0.0)

    43 {

    44   create_and_start();

    45 }

    46 

    47 class CMCheckpointRootsInitialClosure: public VoidClosure {

    48 

    49   ConcurrentMark* _cm;

    50 public:

    51 

    52   CMCheckpointRootsInitialClosure(ConcurrentMark* cm) :

    53     _cm(cm) {}

    54 

    55   void do_void(){

    56     _cm->checkpointRootsInitial();

    57   }

    58 };

    59 

    60 class CMCheckpointRootsFinalClosure: public VoidClosure {

    61 

    62   ConcurrentMark* _cm;

    63 public:

    64 

    65   CMCheckpointRootsFinalClosure(ConcurrentMark* cm) :

    66     _cm(cm) {}

    67 

    68   void do_void(){

    69     _cm->checkpointRootsFinal(false); // !clear_all_soft_refs

    70   }

    71 };

    72 

    73 class CMCleanUp: public VoidClosure {

    74   ConcurrentMark* _cm;

    75 public:

    76 

    77   CMCleanUp(ConcurrentMark* cm) :

    78     _cm(cm) {}

    79 

    80   void do_void(){

    81     _cm->cleanup();

    82   }

    83 };

    84 

    85 

    86 

    87 void ConcurrentMarkThread::run() {

    88   initialize_in_thread();

    89   _vtime_start = os::elapsedVTime();

    90   wait_for_universe_init();

    91 

    92   G1CollectedHeap* g1 = G1CollectedHeap::heap();

    93   G1CollectorPolicy* g1_policy = g1->g1_policy();

    94   G1MMUTracker *mmu_tracker = g1_policy->mmu_tracker();

    95   Thread *current_thread = Thread::current();

    96 

    97   while (!_should_terminate) {

    98     // wait until started is set.

    99     sleepBeforeNextCycle();

   100     {

   101       ResourceMark rm;

   102       HandleMark   hm;

   103       double cycle_start = os::elapsedVTime();

   104       double mark_start_sec = os::elapsedTime();

   105       char verbose_str[128];

   106 

   107       if (PrintGC) {

   108         gclog_or_tty->date_stamp(PrintGCDateStamps);

   109         gclog_or_tty->stamp(PrintGCTimeStamps);

   110         tty->print_cr("[GC concurrent-mark-start]");

   111       }

   112 

   113       if (!g1_policy->in_young_gc_mode()) {

   114         // this ensures the flag is not set if we bail out of the marking

   115         // cycle; normally the flag is cleared immediately after cleanup

   116         g1->set_marking_complete();

   117 

   118         if (g1_policy->adaptive_young_list_length()) {

   119           double now = os::elapsedTime();

   120           double init_prediction_ms = g1_policy->predict_init_time_ms();

   121           jlong sleep_time_ms = mmu_tracker->when_ms(now, init_prediction_ms);

   122           os::sleep(current_thread, sleep_time_ms, false);

   123         }

   124 

   125         // We don't have to skip here if we've been asked to restart, because

   126         // in the worst case we just enqueue a new VM operation to start a

   127         // marking.  Note that the init operation resets has_aborted()

   128         CMCheckpointRootsInitialClosure init_cl(_cm);

   129         strcpy(verbose_str, "GC initial-mark");

   130         VM_CGC_Operation op(&init_cl, verbose_str);

   131         VMThread::execute(&op);

   132       }

   133 

   134       int iter = 0;

   135       do {

   136         iter++;

   137         if (!cm()->has_aborted()) {

   138           _cm->markFromRoots();

   139         } else {

   140           if (TraceConcurrentMark)

   141             gclog_or_tty->print_cr("CM-skip-mark-from-roots");

   142         }

   143 

   144         double mark_end_time = os::elapsedVTime();

   145         double mark_end_sec = os::elapsedTime();

   146         _vtime_mark_accum += (mark_end_time - cycle_start);

   147         if (!cm()->has_aborted()) {

   148           if (g1_policy->adaptive_young_list_length()) {

   149             double now = os::elapsedTime();

   150             double remark_prediction_ms = g1_policy->predict_remark_time_ms();

   151             jlong sleep_time_ms = mmu_tracker->when_ms(now, remark_prediction_ms);

   152             os::sleep(current_thread, sleep_time_ms, false);

   153           }

   154 

   155           if (PrintGC) {

   156             gclog_or_tty->date_stamp(PrintGCDateStamps);

   157             gclog_or_tty->stamp(PrintGCTimeStamps);

   158             gclog_or_tty->print_cr("[GC concurrent-mark-end, %1.7lf sec]",

   159                                       mark_end_sec - mark_start_sec);

   160           }

   161 

   162           CMCheckpointRootsFinalClosure final_cl(_cm);

   163           sprintf(verbose_str, "GC remark");

   164           VM_CGC_Operation op(&final_cl, verbose_str);

   165           VMThread::execute(&op);

   166         } else {

   167           if (TraceConcurrentMark)

   168             gclog_or_tty->print_cr("CM-skip-remark");

   169         }

   170         if (cm()->restart_for_overflow() &&

   171             G1TraceMarkStackOverflow) {

   172           gclog_or_tty->print_cr("Restarting conc marking because of MS overflow "

   173                                  "in remark (restart #%d).", iter);

   174         }

   175 

   176         if (cm()->restart_for_overflow()) {

   177           if (PrintGC) {

   178             gclog_or_tty->date_stamp(PrintGCDateStamps);

   179             gclog_or_tty->stamp(PrintGCTimeStamps);

   180             gclog_or_tty->print_cr("[GC concurrent-mark-restart-for-overflow]");

   181           }

   182         }

   183       } while (cm()->restart_for_overflow());

   184       double counting_start_time = os::elapsedVTime();

   185 

   186       // YSR: These look dubious (i.e. redundant) !!! FIX ME

   187       slt()->manipulatePLL(SurrogateLockerThread::acquirePLL);

   188       slt()->manipulatePLL(SurrogateLockerThread::releaseAndNotifyPLL);

   189 

   190       if (!cm()->has_aborted()) {

   191         double count_start_sec = os::elapsedTime();

   192         if (PrintGC) {

   193           gclog_or_tty->date_stamp(PrintGCDateStamps);

   194           gclog_or_tty->stamp(PrintGCTimeStamps);

   195           gclog_or_tty->print_cr("[GC concurrent-count-start]");

   196         }

   197 

   198         _sts.join();

   199         _cm->calcDesiredRegions();

   200         _sts.leave();

   201 

   202         if (!cm()->has_aborted()) {

   203           double count_end_sec = os::elapsedTime();

   204           if (PrintGC) {

   205             gclog_or_tty->date_stamp(PrintGCDateStamps);

   206             gclog_or_tty->stamp(PrintGCTimeStamps);

   207             gclog_or_tty->print_cr("[GC concurrent-count-end, %1.7lf]",

   208                                    count_end_sec - count_start_sec);

   209           }

   210         }

   211       } else {

   212         if (TraceConcurrentMark) gclog_or_tty->print_cr("CM-skip-end-game");

   213       }

   214       double end_time = os::elapsedVTime();

   215       _vtime_count_accum += (end_time - counting_start_time);

   216       // Update the total virtual time before doing this, since it will try

   217       // to measure it to get the vtime for this marking.  We purposely

   218       // neglect the presumably-short "completeCleanup" phase here.

   219       _vtime_accum = (end_time - _vtime_start);

   220       if (!cm()->has_aborted()) {

   221         if (g1_policy->adaptive_young_list_length()) {

   222           double now = os::elapsedTime();

   223           double cleanup_prediction_ms = g1_policy->predict_cleanup_time_ms();

   224           jlong sleep_time_ms = mmu_tracker->when_ms(now, cleanup_prediction_ms);

   225           os::sleep(current_thread, sleep_time_ms, false);

   226         }

   227 

   228         CMCleanUp cl_cl(_cm);

   229         sprintf(verbose_str, "GC cleanup");

   230         VM_CGC_Operation op(&cl_cl, verbose_str);

   231         VMThread::execute(&op);

   232       } else {

   233         if (TraceConcurrentMark) gclog_or_tty->print_cr("CM-skip-cleanup");

   234         G1CollectedHeap::heap()->set_marking_complete();

   235       }

   236 

   237       if (!cm()->has_aborted()) {

   238         double cleanup_start_sec = os::elapsedTime();

   239         if (PrintGC) {

   240           gclog_or_tty->date_stamp(PrintGCDateStamps);

   241           gclog_or_tty->stamp(PrintGCTimeStamps);

   242           gclog_or_tty->print_cr("[GC concurrent-cleanup-start]");

   243         }

   244 

   245         // Now do the remainder of the cleanup operation.

   246         _sts.join();

   247         _cm->completeCleanup();

   248         if (!cm()->has_aborted()) {

   249           g1_policy->record_concurrent_mark_cleanup_completed();

   250 

   251           double cleanup_end_sec = os::elapsedTime();

   252           if (PrintGC) {

   253             gclog_or_tty->date_stamp(PrintGCDateStamps);

   254             gclog_or_tty->stamp(PrintGCTimeStamps);

   255             gclog_or_tty->print_cr("[GC concurrent-cleanup-end, %1.7lf]",

   256                                    cleanup_end_sec - cleanup_start_sec);

   257           }

   258         }

   259         _sts.leave();

   260       }

   261       // We're done: no more unclean regions coming.

   262       G1CollectedHeap::heap()->set_unclean_regions_coming(false);

   263 

   264       if (cm()->has_aborted()) {

   265         if (PrintGC) {

   266           gclog_or_tty->date_stamp(PrintGCDateStamps);

   267           gclog_or_tty->stamp(PrintGCTimeStamps);

   268           gclog_or_tty->print_cr("[GC concurrent-mark-abort]");

   269         }

   270       }

   271 

   272       _sts.join();

   273       _cm->disable_co_trackers();

   274       _sts.leave();

   275 

   276       // we now want to allow clearing of the marking bitmap to be

   277       // suspended by a collection pause.

   278       _sts.join();

   279       _cm->clearNextBitmap();

   280       _sts.leave();

   281     }

   282   }

   283   assert(_should_terminate, "just checking");

   284 

   285   terminate();

   286 }

   287 

   288 

   289 void ConcurrentMarkThread::yield() {

   290   if (TraceConcurrentMark) gclog_or_tty->print_cr("CM-yield");

   291   _sts.yield("Concurrent Mark");

   292   if (TraceConcurrentMark) gclog_or_tty->print_cr("CM-yield-end");

   293 }

   294 

   295 void ConcurrentMarkThread::stop() {

   296   // it is ok to take late safepoints here, if needed

   297   MutexLockerEx mu(Terminator_lock);

   298   _should_terminate = true;

   299   while (!_has_terminated) {

   300     Terminator_lock->wait();

   301   }

   302   if (TraceConcurrentMark) gclog_or_tty->print_cr("CM-stop");

   303 }

   304 

   305 void ConcurrentMarkThread::print() {

   306   gclog_or_tty->print("\"Concurrent Mark GC Thread\" ");

   307   Thread::print();

   308   gclog_or_tty->cr();

   309 }

   310 

   311 void ConcurrentMarkThread::sleepBeforeNextCycle() {

   312   clear_in_progress();

   313   // We join here because we don't want to do the "shouldConcurrentMark()"

   314   // below while the world is otherwise stopped.

   315   MutexLockerEx x(CGC_lock, Mutex::_no_safepoint_check_flag);

   316   while (!started()) {

   317     if (TraceConcurrentMark) gclog_or_tty->print_cr("CM-sleeping");

   318     CGC_lock->wait(Mutex::_no_safepoint_check_flag);

   319   }

   320   set_in_progress();

   321   clear_started();

   322   if (TraceConcurrentMark) gclog_or_tty->print_cr("CM-starting");

   323 

   324   return;

   325 }

   326 

   327 // Note: this method, although exported by the ConcurrentMarkSweepThread,

   328 // which is a non-JavaThread, can only be called by a JavaThread.

   329 // Currently this is done at vm creation time (post-vm-init) by the

   330 // main/Primordial (Java)Thread.

   331 // XXX Consider changing this in the future to allow the CMS thread

   332 // itself to create this thread?

   333 void ConcurrentMarkThread::makeSurrogateLockerThread(TRAPS) {

   334   assert(_slt == NULL, "SLT already created");

   335   _slt = SurrogateLockerThread::make(THREAD);

   336 }