1/*
2 * Copyright (c) 2005, 2016, 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/concurrentMarkSweepGeneration.inline.hpp"
27#include "gc/cms/concurrentMarkSweepThread.hpp"
28#include "gc/cms/vmCMSOperations.hpp"
29#include "gc/shared/gcLocker.inline.hpp"
30#include "gc/shared/gcTimer.hpp"
31#include "gc/shared/gcTraceTime.inline.hpp"
32#include "gc/shared/isGCActiveMark.hpp"
33#include "runtime/interfaceSupport.hpp"
34#include "runtime/os.hpp"
35#include "utilities/dtrace.hpp"
36
37//////////////////////////////////////////////////////////
38// Methods in abstract class VM_CMS_Operation
39//////////////////////////////////////////////////////////
40void VM_CMS_Operation::verify_before_gc() {
41  if (VerifyBeforeGC &&
42      GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) {
43    GCTraceTime(Info, gc, phases, verify) tm("Verify Before", _collector->_gc_timer_cm);
44    HandleMark hm;
45    FreelistLocker x(_collector);
46    MutexLockerEx  y(_collector->bitMapLock(), Mutex::_no_safepoint_check_flag);
47    GenCollectedHeap::heap()->prepare_for_verify();
48    Universe::verify();
49  }
50}
51
52void VM_CMS_Operation::verify_after_gc() {
53  if (VerifyAfterGC &&
54      GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) {
55    GCTraceTime(Info, gc, phases, verify) tm("Verify After", _collector->_gc_timer_cm);
56    HandleMark hm;
57    FreelistLocker x(_collector);
58    MutexLockerEx  y(_collector->bitMapLock(), Mutex::_no_safepoint_check_flag);
59    Universe::verify();
60  }
61}
62
63bool VM_CMS_Operation::lost_race() const {
64  if (CMSCollector::abstract_state() == CMSCollector::Idling) {
65    // We lost a race to a foreground collection
66    // -- there's nothing to do
67    return true;
68  }
69  assert(CMSCollector::abstract_state() == legal_state(),
70         "Inconsistent collector state?");
71  return false;
72}
73
74bool VM_CMS_Operation::doit_prologue() {
75  assert(Thread::current()->is_ConcurrentGC_thread(), "just checking");
76  assert(!CMSCollector::foregroundGCShouldWait(), "Possible deadlock");
77  assert(!ConcurrentMarkSweepThread::cms_thread_has_cms_token(),
78         "Possible deadlock");
79
80  Heap_lock->lock();
81  if (lost_race()) {
82    assert(_prologue_succeeded == false, "Initialized in c'tor");
83    Heap_lock->unlock();
84  } else {
85    _prologue_succeeded = true;
86  }
87  return _prologue_succeeded;
88}
89
90void VM_CMS_Operation::doit_epilogue() {
91  assert(Thread::current()->is_ConcurrentGC_thread(), "just checking");
92  assert(!CMSCollector::foregroundGCShouldWait(), "Possible deadlock");
93  assert(!ConcurrentMarkSweepThread::cms_thread_has_cms_token(),
94         "Possible deadlock");
95
96  if (Universe::has_reference_pending_list()) {
97    Heap_lock->notify_all();
98  }
99  Heap_lock->unlock();
100}
101
102//////////////////////////////////////////////////////////
103// Methods in class VM_CMS_Initial_Mark
104//////////////////////////////////////////////////////////
105void VM_CMS_Initial_Mark::doit() {
106  if (lost_race()) {
107    // Nothing to do.
108    return;
109  }
110  HS_PRIVATE_CMS_INITMARK_BEGIN();
111  GCIdMark gc_id_mark(_gc_id);
112
113  _collector->_gc_timer_cm->register_gc_pause_start("Initial Mark");
114
115  GenCollectedHeap* gch = GenCollectedHeap::heap();
116  GCCauseSetter gccs(gch, GCCause::_cms_initial_mark);
117
118  VM_CMS_Operation::verify_before_gc();
119
120  IsGCActiveMark x; // stop-world GC active
121  _collector->do_CMS_operation(CMSCollector::CMS_op_checkpointRootsInitial, gch->gc_cause());
122
123  VM_CMS_Operation::verify_after_gc();
124
125  _collector->_gc_timer_cm->register_gc_pause_end();
126
127  HS_PRIVATE_CMS_INITMARK_END();
128}
129
130//////////////////////////////////////////////////////////
131// Methods in class VM_CMS_Final_Remark_Operation
132//////////////////////////////////////////////////////////
133void VM_CMS_Final_Remark::doit() {
134  if (lost_race()) {
135    // Nothing to do.
136    return;
137  }
138  HS_PRIVATE_CMS_REMARK_BEGIN();
139  GCIdMark gc_id_mark(_gc_id);
140
141  _collector->_gc_timer_cm->register_gc_pause_start("Final Mark");
142
143  GenCollectedHeap* gch = GenCollectedHeap::heap();
144  GCCauseSetter gccs(gch, GCCause::_cms_final_remark);
145
146  VM_CMS_Operation::verify_before_gc();
147
148  IsGCActiveMark x; // stop-world GC active
149  _collector->do_CMS_operation(CMSCollector::CMS_op_checkpointRootsFinal, gch->gc_cause());
150
151  VM_CMS_Operation::verify_after_gc();
152
153  _collector->save_heap_summary();
154  _collector->_gc_timer_cm->register_gc_pause_end();
155
156  HS_PRIVATE_CMS_REMARK_END();
157}
158
159// VM operation to invoke a concurrent collection of a
160// GenCollectedHeap heap.
161void VM_GenCollectFullConcurrent::doit() {
162  assert(Thread::current()->is_VM_thread(), "Should be VM thread");
163  assert(GCLockerInvokesConcurrent || ExplicitGCInvokesConcurrent, "Unexpected");
164
165  GenCollectedHeap* gch = GenCollectedHeap::heap();
166  if (_gc_count_before == gch->total_collections()) {
167    // The "full" of do_full_collection call below "forces"
168    // a collection; the second arg, 0, below ensures that
169    // only the young gen is collected. XXX In the future,
170    // we'll probably need to have something in this interface
171    // to say do this only if we are sure we will not bail
172    // out to a full collection in this attempt, but that's
173    // for the future.
174    assert(SafepointSynchronize::is_at_safepoint(),
175      "We can only be executing this arm of if at a safepoint");
176    GCCauseSetter gccs(gch, _gc_cause);
177    gch->do_full_collection(gch->must_clear_all_soft_refs(), GenCollectedHeap::YoungGen);
178  } // Else no need for a foreground young gc
179  assert((_gc_count_before < gch->total_collections()) ||
180         (GCLocker::is_active() /* gc may have been skipped */
181          && (_gc_count_before == gch->total_collections())),
182         "total_collections() should be monotonically increasing");
183
184  MutexLockerEx x(FullGCCount_lock, Mutex::_no_safepoint_check_flag);
185  assert(_full_gc_count_before <= gch->total_full_collections(), "Error");
186  if (gch->total_full_collections() == _full_gc_count_before) {
187    // Nudge the CMS thread to start a concurrent collection.
188    CMSCollector::request_full_gc(_full_gc_count_before, _gc_cause);
189  } else {
190    assert(_full_gc_count_before < gch->total_full_collections(), "Error");
191    FullGCCount_lock->notify_all();  // Inform the Java thread its work is done
192  }
193}
194
195bool VM_GenCollectFullConcurrent::evaluate_at_safepoint() const {
196  Thread* thr = Thread::current();
197  assert(thr != NULL, "Unexpected tid");
198  if (!thr->is_Java_thread()) {
199    assert(thr->is_VM_thread(), "Expected to be evaluated by VM thread");
200    GenCollectedHeap* gch = GenCollectedHeap::heap();
201    if (_gc_count_before != gch->total_collections()) {
202      // No need to do a young gc, we'll just nudge the CMS thread
203      // in the doit() method above, to be executed soon.
204      assert(_gc_count_before < gch->total_collections(),
205             "total_collections() should be monotonically increasing");
206      return false;  // no need for foreground young gc
207    }
208  }
209  return true;       // may still need foreground young gc
210}
211
212
213void VM_GenCollectFullConcurrent::doit_epilogue() {
214  Thread* thr = Thread::current();
215  assert(thr->is_Java_thread(), "just checking");
216  JavaThread* jt = (JavaThread*)thr;
217
218  if (Universe::has_reference_pending_list()) {
219    Heap_lock->notify_all();
220  }
221  Heap_lock->unlock();
222
223  // It is fine to test whether completed collections has
224  // exceeded our request count without locking because
225  // the completion count is monotonically increasing;
226  // this will break for very long-running apps when the
227  // count overflows and wraps around. XXX fix me !!!
228  // e.g. at the rate of 1 full gc per ms, this could
229  // overflow in about 1000 years.
230  GenCollectedHeap* gch = GenCollectedHeap::heap();
231  if (_gc_cause != GCCause::_gc_locker &&
232      gch->total_full_collections_completed() <= _full_gc_count_before) {
233    // maybe we should change the condition to test _gc_cause ==
234    // GCCause::_java_lang_system_gc or GCCause::_dcmd_gc_run,
235    // instead of _gc_cause != GCCause::_gc_locker
236    assert(GCCause::is_user_requested_gc(_gc_cause),
237           "the only way to get here if this was a System.gc()-induced GC");
238    assert(ExplicitGCInvokesConcurrent, "Error");
239    // Now, wait for witnessing concurrent gc cycle to complete,
240    // but do so in native mode, because we want to lock the
241    // FullGCEvent_lock, which may be needed by the VM thread
242    // or by the CMS thread, so we do not want to be suspended
243    // while holding that lock.
244    ThreadToNativeFromVM native(jt);
245    MutexLockerEx ml(FullGCCount_lock, Mutex::_no_safepoint_check_flag);
246    // Either a concurrent or a stop-world full gc is sufficient
247    // witness to our request.
248    while (gch->total_full_collections_completed() <= _full_gc_count_before) {
249      FullGCCount_lock->wait(Mutex::_no_safepoint_check_flag);
250    }
251  }
252}
253