Tue, 21 Aug 2012 14:10:39 -0700
7185699: G1: Prediction model discrepancies
Summary: Correct the result value of G1CollectedHeap::pending_card_num(). Change the code that calculates the GC efficiency of a non-young heap region to use historical data from mixed GCs and the actual number of live bytes when predicting how long it would take to collect the region. Changes were also reviewed by Thomas Schatzl.
Reviewed-by: azeemj, brutisso
1 /*
2 * Copyright (c) 2001, 2012, 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 */
25 #include "precompiled.hpp"
26 #include "gc_implementation/g1/concurrentMarkThread.inline.hpp"
27 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
28 #include "gc_implementation/g1/g1CollectorPolicy.hpp"
29 #include "gc_implementation/g1/g1Log.hpp"
30 #include "gc_implementation/g1/vm_operations_g1.hpp"
31 #include "gc_implementation/shared/isGCActiveMark.hpp"
32 #include "gc_implementation/g1/vm_operations_g1.hpp"
33 #include "runtime/interfaceSupport.hpp"
35 VM_G1CollectForAllocation::VM_G1CollectForAllocation(
36 unsigned int gc_count_before,
37 size_t word_size)
38 : VM_G1OperationWithAllocRequest(gc_count_before, word_size,
39 GCCause::_allocation_failure) {
40 guarantee(word_size > 0, "an allocation should always be requested");
41 }
43 void VM_G1CollectForAllocation::doit() {
44 G1CollectedHeap* g1h = G1CollectedHeap::heap();
45 GCCauseSetter x(g1h, _gc_cause);
46 _result = g1h->satisfy_failed_allocation(_word_size, &_pause_succeeded);
47 assert(_result == NULL || _pause_succeeded,
48 "if we get back a result, the pause should have succeeded");
49 }
51 void VM_G1CollectFull::doit() {
52 G1CollectedHeap* g1h = G1CollectedHeap::heap();
53 GCCauseSetter x(g1h, _gc_cause);
54 g1h->do_full_collection(false /* clear_all_soft_refs */);
55 }
57 VM_G1IncCollectionPause::VM_G1IncCollectionPause(
58 unsigned int gc_count_before,
59 size_t word_size,
60 bool should_initiate_conc_mark,
61 double target_pause_time_ms,
62 GCCause::Cause gc_cause)
63 : VM_G1OperationWithAllocRequest(gc_count_before, word_size, gc_cause),
64 _should_initiate_conc_mark(should_initiate_conc_mark),
65 _target_pause_time_ms(target_pause_time_ms),
66 _should_retry_gc(false),
67 _old_marking_cycles_completed_before(0) {
68 guarantee(target_pause_time_ms > 0.0,
69 err_msg("target_pause_time_ms = %1.6lf should be positive",
70 target_pause_time_ms));
71 guarantee(word_size == 0 || gc_cause == GCCause::_g1_inc_collection_pause,
72 "we can only request an allocation if the GC cause is for "
73 "an incremental GC pause");
74 _gc_cause = gc_cause;
75 }
77 bool VM_G1IncCollectionPause::doit_prologue() {
78 bool res = VM_GC_Operation::doit_prologue();
79 if (!res) {
80 if (_should_initiate_conc_mark) {
81 // The prologue can fail for a couple of reasons. The first is that another GC
82 // got scheduled and prevented the scheduling of the initial mark GC. The
83 // second is that the GC locker may be active and the heap can't be expanded.
84 // In both cases we want to retry the GC so that the initial mark pause is
85 // actually scheduled. In the second case, however, we should stall until
86 // until the GC locker is no longer active and then retry the initial mark GC.
87 _should_retry_gc = true;
88 }
89 }
90 return res;
91 }
93 void VM_G1IncCollectionPause::doit() {
94 G1CollectedHeap* g1h = G1CollectedHeap::heap();
95 assert(!_should_initiate_conc_mark ||
96 ((_gc_cause == GCCause::_gc_locker && GCLockerInvokesConcurrent) ||
97 (_gc_cause == GCCause::_java_lang_system_gc && ExplicitGCInvokesConcurrent) ||
98 _gc_cause == GCCause::_g1_humongous_allocation),
99 "only a GC locker, a System.gc() or a hum allocation induced GC should start a cycle");
101 if (_word_size > 0) {
102 // An allocation has been requested. So, try to do that first.
103 _result = g1h->attempt_allocation_at_safepoint(_word_size,
104 false /* expect_null_cur_alloc_region */);
105 if (_result != NULL) {
106 // If we can successfully allocate before we actually do the
107 // pause then we will consider this pause successful.
108 _pause_succeeded = true;
109 return;
110 }
111 }
113 GCCauseSetter x(g1h, _gc_cause);
114 if (_should_initiate_conc_mark) {
115 // It's safer to read old_marking_cycles_completed() here, given
116 // that noone else will be updating it concurrently. Since we'll
117 // only need it if we're initiating a marking cycle, no point in
118 // setting it earlier.
119 _old_marking_cycles_completed_before = g1h->old_marking_cycles_completed();
121 // At this point we are supposed to start a concurrent cycle. We
122 // will do so if one is not already in progress.
123 bool res = g1h->g1_policy()->force_initial_mark_if_outside_cycle(_gc_cause);
125 // The above routine returns true if we were able to force the
126 // next GC pause to be an initial mark; it returns false if a
127 // marking cycle is already in progress.
128 //
129 // If a marking cycle is already in progress just return and skip the
130 // pause below - if the reason for requesting this initial mark pause
131 // was due to a System.gc() then the requesting thread should block in
132 // doit_epilogue() until the marking cycle is complete.
133 //
134 // If this initial mark pause was requested as part of a humongous
135 // allocation then we know that the marking cycle must just have
136 // been started by another thread (possibly also allocating a humongous
137 // object) as there was no active marking cycle when the requesting
138 // thread checked before calling collect() in
139 // attempt_allocation_humongous(). Retrying the GC, in this case,
140 // will cause the requesting thread to spin inside collect() until the
141 // just started marking cycle is complete - which may be a while. So
142 // we do NOT retry the GC.
143 if (!res) {
144 assert(_word_size == 0, "Concurrent Full GC/Humongous Object IM shouldn't be allocating");
145 if (_gc_cause != GCCause::_g1_humongous_allocation) {
146 _should_retry_gc = true;
147 }
148 return;
149 }
150 }
152 _pause_succeeded =
153 g1h->do_collection_pause_at_safepoint(_target_pause_time_ms);
154 if (_pause_succeeded && _word_size > 0) {
155 // An allocation had been requested.
156 _result = g1h->attempt_allocation_at_safepoint(_word_size,
157 true /* expect_null_cur_alloc_region */);
158 } else {
159 assert(_result == NULL, "invariant");
160 if (!_pause_succeeded) {
161 // Another possible reason reason for the pause to not be successful
162 // is that, again, the GC locker is active (and has become active
163 // since the prologue was executed). In this case we should retry
164 // the pause after waiting for the GC locker to become inactive.
165 _should_retry_gc = true;
166 }
167 }
168 }
170 void VM_G1IncCollectionPause::doit_epilogue() {
171 VM_GC_Operation::doit_epilogue();
173 // If the pause was initiated by a System.gc() and
174 // +ExplicitGCInvokesConcurrent, we have to wait here for the cycle
175 // that just started (or maybe one that was already in progress) to
176 // finish.
177 if (_gc_cause == GCCause::_java_lang_system_gc &&
178 _should_initiate_conc_mark) {
179 assert(ExplicitGCInvokesConcurrent,
180 "the only way to be here is if ExplicitGCInvokesConcurrent is set");
182 G1CollectedHeap* g1h = G1CollectedHeap::heap();
184 // In the doit() method we saved g1h->old_marking_cycles_completed()
185 // in the _old_marking_cycles_completed_before field. We have to
186 // wait until we observe that g1h->old_marking_cycles_completed()
187 // has increased by at least one. This can happen if a) we started
188 // a cycle and it completes, b) a cycle already in progress
189 // completes, or c) a Full GC happens.
191 // If the condition has already been reached, there's no point in
192 // actually taking the lock and doing the wait.
193 if (g1h->old_marking_cycles_completed() <=
194 _old_marking_cycles_completed_before) {
195 // The following is largely copied from CMS
197 Thread* thr = Thread::current();
198 assert(thr->is_Java_thread(), "invariant");
199 JavaThread* jt = (JavaThread*)thr;
200 ThreadToNativeFromVM native(jt);
202 MutexLockerEx x(FullGCCount_lock, Mutex::_no_safepoint_check_flag);
203 while (g1h->old_marking_cycles_completed() <=
204 _old_marking_cycles_completed_before) {
205 FullGCCount_lock->wait(Mutex::_no_safepoint_check_flag);
206 }
207 }
208 }
209 }
211 void VM_CGC_Operation::acquire_pending_list_lock() {
212 assert(_needs_pll, "don't call this otherwise");
213 // The caller may block while communicating
214 // with the SLT thread in order to acquire/release the PLL.
215 ConcurrentMarkThread::slt()->
216 manipulatePLL(SurrogateLockerThread::acquirePLL);
217 }
219 void VM_CGC_Operation::release_and_notify_pending_list_lock() {
220 assert(_needs_pll, "don't call this otherwise");
221 // The caller may block while communicating
222 // with the SLT thread in order to acquire/release the PLL.
223 ConcurrentMarkThread::slt()->
224 manipulatePLL(SurrogateLockerThread::releaseAndNotifyPLL);
225 }
227 void VM_CGC_Operation::doit() {
228 gclog_or_tty->date_stamp(G1Log::fine() && PrintGCDateStamps);
229 TraceCPUTime tcpu(G1Log::finer(), true, gclog_or_tty);
230 TraceTime t(_printGCMessage, G1Log::fine(), true, gclog_or_tty);
231 SharedHeap* sh = SharedHeap::heap();
232 // This could go away if CollectedHeap gave access to _gc_is_active...
233 if (sh != NULL) {
234 IsGCActiveMark x;
235 _cl->do_void();
236 } else {
237 _cl->do_void();
238 }
239 }
241 bool VM_CGC_Operation::doit_prologue() {
242 // Note the relative order of the locks must match that in
243 // VM_GC_Operation::doit_prologue() or deadlocks can occur
244 if (_needs_pll) {
245 acquire_pending_list_lock();
246 }
248 Heap_lock->lock();
249 SharedHeap::heap()->_thread_holds_heap_lock_for_gc = true;
250 return true;
251 }
253 void VM_CGC_Operation::doit_epilogue() {
254 // Note the relative order of the unlocks must match that in
255 // VM_GC_Operation::doit_epilogue()
256 SharedHeap::heap()->_thread_holds_heap_lock_for_gc = false;
257 Heap_lock->unlock();
258 if (_needs_pll) {
259 release_and_notify_pending_list_lock();
260 }
261 }