1 /*

     2  * Copyright (c) 2005, 2019, 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/cms/cmsHeap.hpp"

    27 #include "gc/cms/cmsVMOperations.hpp"

    28 #include "gc/cms/concurrentMarkSweepGeneration.inline.hpp"

    29 #include "gc/cms/concurrentMarkSweepThread.hpp"

    30 #include "gc/shared/gcLocker.hpp"

    31 #include "gc/shared/gcTimer.hpp"

    32 #include "gc/shared/gcTraceTime.inline.hpp"

    33 #include "gc/shared/isGCActiveMark.hpp"

    34 #include "memory/universe.hpp"

    35 #include "runtime/handles.inline.hpp"

    36 #include "runtime/interfaceSupport.inline.hpp"

    37 #include "runtime/os.hpp"

    38 #include "utilities/dtrace.hpp"

    39 

    40 //////////////////////////////////////////////////////////

    41 // Methods in abstract class VM_CMS_Operation

    42 //////////////////////////////////////////////////////////

    43 void VM_CMS_Operation::verify_before_gc() {

    44   if (VerifyBeforeGC &&

    45       CMSHeap::heap()->total_collections() >= VerifyGCStartAt) {

    46     GCTraceTime(Info, gc, phases, verify) tm("Verify Before", _collector->_gc_timer_cm);

    47     HandleMark hm;

    48     FreelistLocker x(_collector);

    49     MutexLocker  y(_collector->bitMapLock(), Mutex::_no_safepoint_check_flag);

    50     CMSHeap::heap()->prepare_for_verify();

    51     Universe::verify();

    52   }

    53 }

    54 

    55 void VM_CMS_Operation::verify_after_gc() {

    56   if (VerifyAfterGC &&

    57       CMSHeap::heap()->total_collections() >= VerifyGCStartAt) {

    58     GCTraceTime(Info, gc, phases, verify) tm("Verify After", _collector->_gc_timer_cm);

    59     HandleMark hm;

    60     FreelistLocker x(_collector);

    61     MutexLocker  y(_collector->bitMapLock(), Mutex::_no_safepoint_check_flag);

    62     Universe::verify();

    63   }

    64 }

    65 

    66 bool VM_CMS_Operation::lost_race() const {

    67   if (CMSCollector::abstract_state() == CMSCollector::Idling) {

    68     // We lost a race to a foreground collection

    69     // -- there's nothing to do

    70     return true;

    71   }

    72   assert(CMSCollector::abstract_state() == legal_state(),

    73          "Inconsistent collector state?");

    74   return false;

    75 }

    76 

    77 bool VM_CMS_Operation::doit_prologue() {

    78   assert(Thread::current()->is_ConcurrentGC_thread(), "just checking");

    79   assert(!CMSCollector::foregroundGCShouldWait(), "Possible deadlock");

    80   assert(!ConcurrentMarkSweepThread::cms_thread_has_cms_token(),

    81          "Possible deadlock");

    82 

    83   Heap_lock->lock();

    84   if (lost_race()) {

    85     assert(_prologue_succeeded == false, "Initialized in c'tor");

    86     Heap_lock->unlock();

    87   } else {

    88     _prologue_succeeded = true;

    89   }

    90   return _prologue_succeeded;

    91 }

    92 

    93 void VM_CMS_Operation::doit_epilogue() {

    94   assert(Thread::current()->is_ConcurrentGC_thread(), "just checking");

    95   assert(!CMSCollector::foregroundGCShouldWait(), "Possible deadlock");

    96   assert(!ConcurrentMarkSweepThread::cms_thread_has_cms_token(),

    97          "Possible deadlock");

    98 

    99   if (Universe::has_reference_pending_list()) {

   100     Heap_lock->notify_all();

   101   }

   102   Heap_lock->unlock();

   103 }

   104 

   105 //////////////////////////////////////////////////////////

   106 // Methods in class VM_CMS_Initial_Mark

   107 //////////////////////////////////////////////////////////

   108 void VM_CMS_Initial_Mark::doit() {

   109   if (lost_race()) {

   110     // Nothing to do.

   111     return;

   112   }

   113   HS_PRIVATE_CMS_INITMARK_BEGIN();

   114   GCIdMark gc_id_mark(_gc_id);

   115 

   116   _collector->_gc_timer_cm->register_gc_pause_start("Initial Mark");

   117 

   118   CMSHeap* heap = CMSHeap::heap();

   119   GCCauseSetter gccs(heap, GCCause::_cms_initial_mark);

   120 

   121   VM_CMS_Operation::verify_before_gc();

   122 

   123   IsGCActiveMark x; // stop-world GC active

   124   _collector->do_CMS_operation(CMSCollector::CMS_op_checkpointRootsInitial, heap->gc_cause());

   125 

   126   VM_CMS_Operation::verify_after_gc();

   127 

   128   _collector->_gc_timer_cm->register_gc_pause_end();

   129 

   130   HS_PRIVATE_CMS_INITMARK_END();

   131 }

   132 

   133 //////////////////////////////////////////////////////////

   134 // Methods in class VM_CMS_Final_Remark_Operation

   135 //////////////////////////////////////////////////////////

   136 void VM_CMS_Final_Remark::doit() {

   137   if (lost_race()) {

   138     // Nothing to do.

   139     return;

   140   }

   141   HS_PRIVATE_CMS_REMARK_BEGIN();

   142   GCIdMark gc_id_mark(_gc_id);

   143 

   144   _collector->_gc_timer_cm->register_gc_pause_start("Final Mark");

   145 

   146   CMSHeap* heap = CMSHeap::heap();

   147   GCCauseSetter gccs(heap, GCCause::_cms_final_remark);

   148 

   149   VM_CMS_Operation::verify_before_gc();

   150 

   151   IsGCActiveMark x; // stop-world GC active

   152   _collector->do_CMS_operation(CMSCollector::CMS_op_checkpointRootsFinal, heap->gc_cause());

   153 

   154   VM_CMS_Operation::verify_after_gc();

   155 

   156   _collector->save_heap_summary();

   157   _collector->_gc_timer_cm->register_gc_pause_end();

   158 

   159   HS_PRIVATE_CMS_REMARK_END();

   160 }

   161 

   162 // VM operation to invoke a concurrent collection of a

   163 // GenCollectedHeap heap.

   164 void VM_GenCollectFullConcurrent::doit() {

   165   assert(Thread::current()->is_VM_thread(), "Should be VM thread");

   166   assert(GCLockerInvokesConcurrent || ExplicitGCInvokesConcurrent, "Unexpected");

   167 

   168   CMSHeap* heap = CMSHeap::heap();

   169   if (_gc_count_before == heap->total_collections()) {

   170     // The "full" of do_full_collection call below "forces"

   171     // a collection; the second arg, 0, below ensures that

   172     // only the young gen is collected. XXX In the future,

   173     // we'll probably need to have something in this interface

   174     // to say do this only if we are sure we will not bail

   175     // out to a full collection in this attempt, but that's

   176     // for the future.

   177     assert(SafepointSynchronize::is_at_safepoint(),

   178       "We can only be executing this arm of if at a safepoint");

   179     GCCauseSetter gccs(heap, _gc_cause);

   180     heap->do_full_collection(heap->must_clear_all_soft_refs(), GenCollectedHeap::YoungGen);

   181   } // Else no need for a foreground young gc

   182   assert((_gc_count_before < heap->total_collections()) ||

   183          (GCLocker::is_active() /* gc may have been skipped */

   184           && (_gc_count_before == heap->total_collections())),

   185          "total_collections() should be monotonically increasing");

   186 

   187   MutexLocker x(FullGCCount_lock, Mutex::_no_safepoint_check_flag);

   188   assert(_full_gc_count_before <= heap->total_full_collections(), "Error");

   189   if (heap->total_full_collections() == _full_gc_count_before) {

   190     // Nudge the CMS thread to start a concurrent collection.

   191     CMSCollector::request_full_gc(_full_gc_count_before, _gc_cause);

   192   } else {

   193     assert(_full_gc_count_before < heap->total_full_collections(), "Error");

   194     FullGCCount_lock->notify_all();  // Inform the Java thread its work is done

   195   }

   196 }

   197 

   198 bool VM_GenCollectFullConcurrent::evaluate_at_safepoint() const {

   199   Thread* thr = Thread::current();

   200   assert(thr != NULL, "Unexpected tid");

   201   if (!thr->is_Java_thread()) {

   202     assert(thr->is_VM_thread(), "Expected to be evaluated by VM thread");

   203     CMSHeap* heap = CMSHeap::heap();

   204     if (_gc_count_before != heap->total_collections()) {

   205       // No need to do a young gc, we'll just nudge the CMS thread

   206       // in the doit() method above, to be executed soon.

   207       assert(_gc_count_before < heap->total_collections(),

   208              "total_collections() should be monotonically increasing");

   209       return false;  // no need for foreground young gc

   210     }

   211   }

   212   return true;       // may still need foreground young gc

   213 }

   214 

   215 

   216 void VM_GenCollectFullConcurrent::doit_epilogue() {

   217   Thread* thr = Thread::current();

   218   assert(thr->is_Java_thread(), "just checking");

   219   JavaThread* jt = (JavaThread*)thr;

   220 

   221   if (Universe::has_reference_pending_list()) {

   222     Heap_lock->notify_all();

   223   }

   224   Heap_lock->unlock();

   225 

   226   // It is fine to test whether completed collections has

   227   // exceeded our request count without locking because

   228   // the completion count is monotonically increasing;

   229   // this will break for very long-running apps when the

   230   // count overflows and wraps around. XXX fix me !!!

   231   // e.g. at the rate of 1 full gc per ms, this could

   232   // overflow in about 1000 years.

   233   CMSHeap* heap = CMSHeap::heap();

   234   if (_gc_cause != GCCause::_gc_locker &&

   235       heap->total_full_collections_completed() <= _full_gc_count_before) {

   236     // maybe we should change the condition to test _gc_cause ==

   237     // GCCause::_java_lang_system_gc or GCCause::_dcmd_gc_run,

   238     // instead of _gc_cause != GCCause::_gc_locker

   239     assert(GCCause::is_user_requested_gc(_gc_cause),

   240            "the only way to get here if this was a System.gc()-induced GC");

   241     assert(ExplicitGCInvokesConcurrent, "Error");

   242     // Now, wait for witnessing concurrent gc cycle to complete,

   243     // but do so in native mode, because we want to lock the

   244     // FullGCEvent_lock, which may be needed by the VM thread

   245     // or by the CMS thread, so we do not want to be suspended

   246     // while holding that lock.

   247     ThreadToNativeFromVM native(jt);

   248     MutexLocker ml(FullGCCount_lock, Mutex::_no_safepoint_check_flag);

   249     // Either a concurrent or a stop-world full gc is sufficient

   250     // witness to our request.

   251     while (heap->total_full_collections_completed() <= _full_gc_count_before) {

   252       FullGCCount_lock->wait_without_safepoint_check();

   253     }

   254   }

   255 }