Mercurial > hg > graal-compiler
annotate src/share/vm/gc_implementation/g1/vm_operations_g1.cpp @ 17833:bfdf528be8e8
8038498: Fix includes and C inlining after 8035330
Summary: Change 8035330: Remove G1ParScanPartialArrayClosure and G1ParScanHeapEvacClosure broke the debug build on AIX. The method do_oop_partial_array() is added in a header, but requires the inline function par_write_ref() through several inlined calls. In some cpp files, like arguments.cpp, par_write_ref() is not defined as the corresponding inline header and is not included. The AIX debug VM does not start because of the missing symbol. This change solves this by cleaning up include dependencies.
Reviewed-by: tschatzl, stefank
author | tschatzl |
---|---|
date | Fri, 04 Apr 2014 10:43:56 +0200 |
parents | f7d3b4387a16 |
children | 0982ec23da03 |
rev | line source |
---|---|
342 | 1 /* |
10405 | 2 * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved. |
342 | 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 * | |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1088
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1088
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1088
diff
changeset
|
21 * questions. |
342 | 22 * |
23 */ | |
24 | |
1972 | 25 #include "precompiled.hpp" |
4022
db89aa49298f
7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents:
3914
diff
changeset
|
26 #include "gc_implementation/g1/concurrentMarkThread.inline.hpp" |
1972 | 27 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" |
28 #include "gc_implementation/g1/g1CollectorPolicy.hpp" | |
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5963
diff
changeset
|
29 #include "gc_implementation/g1/g1Log.hpp" |
1972 | 30 #include "gc_implementation/g1/vm_operations_g1.hpp" |
10405 | 31 #include "gc_implementation/shared/gcTimer.hpp" |
32 #include "gc_implementation/shared/gcTraceTime.hpp" | |
1972 | 33 #include "gc_implementation/shared/isGCActiveMark.hpp" |
1973 | 34 #include "gc_implementation/g1/vm_operations_g1.hpp" |
1972 | 35 #include "runtime/interfaceSupport.hpp" |
342 | 36 |
1973 | 37 VM_G1CollectForAllocation::VM_G1CollectForAllocation( |
38 unsigned int gc_count_before, | |
39 size_t word_size) | |
5963
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
40 : VM_G1OperationWithAllocRequest(gc_count_before, word_size, |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
41 GCCause::_allocation_failure) { |
1973 | 42 guarantee(word_size > 0, "an allocation should always be requested"); |
43 } | |
44 | |
342 | 45 void VM_G1CollectForAllocation::doit() { |
46 G1CollectedHeap* g1h = G1CollectedHeap::heap(); | |
6062
1096fc5a52eb
7168294: G1: Some Full GCs incorrectly report GC cause as "No GC"
johnc
parents:
6007
diff
changeset
|
47 GCCauseSetter x(g1h, _gc_cause); |
1973 | 48 _result = g1h->satisfy_failed_allocation(_word_size, &_pause_succeeded); |
49 assert(_result == NULL || _pause_succeeded, | |
50 "if we get back a result, the pause should have succeeded"); | |
342 | 51 } |
52 | |
53 void VM_G1CollectFull::doit() { | |
54 G1CollectedHeap* g1h = G1CollectedHeap::heap(); | |
55 GCCauseSetter x(g1h, _gc_cause); | |
56 g1h->do_full_collection(false /* clear_all_soft_refs */); | |
57 } | |
58 | |
1973 | 59 VM_G1IncCollectionPause::VM_G1IncCollectionPause( |
60 unsigned int gc_count_before, | |
61 size_t word_size, | |
62 bool should_initiate_conc_mark, | |
63 double target_pause_time_ms, | |
64 GCCause::Cause gc_cause) | |
5963
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
65 : VM_G1OperationWithAllocRequest(gc_count_before, word_size, gc_cause), |
1973 | 66 _should_initiate_conc_mark(should_initiate_conc_mark), |
67 _target_pause_time_ms(target_pause_time_ms), | |
5963
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
68 _should_retry_gc(false), |
6120
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6062
diff
changeset
|
69 _old_marking_cycles_completed_before(0) { |
1973 | 70 guarantee(target_pause_time_ms > 0.0, |
71 err_msg("target_pause_time_ms = %1.6lf should be positive", | |
72 target_pause_time_ms)); | |
73 _gc_cause = gc_cause; | |
74 } | |
75 | |
5963
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
76 bool VM_G1IncCollectionPause::doit_prologue() { |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
77 bool res = VM_GC_Operation::doit_prologue(); |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
78 if (!res) { |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
79 if (_should_initiate_conc_mark) { |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
80 // The prologue can fail for a couple of reasons. The first is that another GC |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
81 // got scheduled and prevented the scheduling of the initial mark GC. The |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
82 // second is that the GC locker may be active and the heap can't be expanded. |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
83 // In both cases we want to retry the GC so that the initial mark pause is |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
84 // actually scheduled. In the second case, however, we should stall until |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
85 // until the GC locker is no longer active and then retry the initial mark GC. |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
86 _should_retry_gc = true; |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
87 } |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
88 } |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
89 return res; |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
90 } |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
91 |
342 | 92 void VM_G1IncCollectionPause::doit() { |
93 G1CollectedHeap* g1h = G1CollectedHeap::heap(); | |
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
94 assert(!_should_initiate_conc_mark || |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
95 ((_gc_cause == GCCause::_gc_locker && GCLockerInvokesConcurrent) || |
4829
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4022
diff
changeset
|
96 (_gc_cause == GCCause::_java_lang_system_gc && ExplicitGCInvokesConcurrent) || |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4022
diff
changeset
|
97 _gc_cause == GCCause::_g1_humongous_allocation), |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4022
diff
changeset
|
98 "only a GC locker, a System.gc() or a hum allocation induced GC should start a cycle"); |
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
99 |
1973 | 100 if (_word_size > 0) { |
101 // An allocation has been requested. So, try to do that first. | |
102 _result = g1h->attempt_allocation_at_safepoint(_word_size, | |
103 false /* expect_null_cur_alloc_region */); | |
104 if (_result != NULL) { | |
105 // If we can successfully allocate before we actually do the | |
106 // pause then we will consider this pause successful. | |
107 _pause_succeeded = true; | |
108 return; | |
109 } | |
110 } | |
111 | |
1088
3fc996d4edd2
6902303: G1: ScavengeALot should cause an incremental, rather than a full, collection
ysr
parents:
844
diff
changeset
|
112 GCCauseSetter x(g1h, _gc_cause); |
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
113 if (_should_initiate_conc_mark) { |
6120
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6062
diff
changeset
|
114 // It's safer to read old_marking_cycles_completed() here, given |
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
115 // that noone else will be updating it concurrently. Since we'll |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
116 // only need it if we're initiating a marking cycle, no point in |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
117 // setting it earlier. |
6120
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6062
diff
changeset
|
118 _old_marking_cycles_completed_before = g1h->old_marking_cycles_completed(); |
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
119 |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
120 // At this point we are supposed to start a concurrent cycle. We |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
121 // will do so if one is not already in progress. |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3773
diff
changeset
|
122 bool res = g1h->g1_policy()->force_initial_mark_if_outside_cycle(_gc_cause); |
3773
5130fa1b24f1
7045751: G1: +ExplicitGCInvokesConcurrent causes excessive single region evacuation pauses
johnc
parents:
2426
diff
changeset
|
123 |
5130fa1b24f1
7045751: G1: +ExplicitGCInvokesConcurrent causes excessive single region evacuation pauses
johnc
parents:
2426
diff
changeset
|
124 // The above routine returns true if we were able to force the |
5130fa1b24f1
7045751: G1: +ExplicitGCInvokesConcurrent causes excessive single region evacuation pauses
johnc
parents:
2426
diff
changeset
|
125 // next GC pause to be an initial mark; it returns false if a |
5130fa1b24f1
7045751: G1: +ExplicitGCInvokesConcurrent causes excessive single region evacuation pauses
johnc
parents:
2426
diff
changeset
|
126 // marking cycle is already in progress. |
5130fa1b24f1
7045751: G1: +ExplicitGCInvokesConcurrent causes excessive single region evacuation pauses
johnc
parents:
2426
diff
changeset
|
127 // |
5963
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
128 // If a marking cycle is already in progress just return and skip the |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
129 // pause below - if the reason for requesting this initial mark pause |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
130 // was due to a System.gc() then the requesting thread should block in |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
131 // doit_epilogue() until the marking cycle is complete. |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
132 // |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
133 // If this initial mark pause was requested as part of a humongous |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
134 // allocation then we know that the marking cycle must just have |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
135 // been started by another thread (possibly also allocating a humongous |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
136 // object) as there was no active marking cycle when the requesting |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
137 // thread checked before calling collect() in |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
138 // attempt_allocation_humongous(). Retrying the GC, in this case, |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
139 // will cause the requesting thread to spin inside collect() until the |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
140 // just started marking cycle is complete - which may be a while. So |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
141 // we do NOT retry the GC. |
3773
5130fa1b24f1
7045751: G1: +ExplicitGCInvokesConcurrent causes excessive single region evacuation pauses
johnc
parents:
2426
diff
changeset
|
142 if (!res) { |
5963
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
143 assert(_word_size == 0, "Concurrent Full GC/Humongous Object IM shouldn't be allocating"); |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
144 if (_gc_cause != GCCause::_g1_humongous_allocation) { |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
145 _should_retry_gc = true; |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
146 } |
3773
5130fa1b24f1
7045751: G1: +ExplicitGCInvokesConcurrent causes excessive single region evacuation pauses
johnc
parents:
2426
diff
changeset
|
147 return; |
5130fa1b24f1
7045751: G1: +ExplicitGCInvokesConcurrent causes excessive single region evacuation pauses
johnc
parents:
2426
diff
changeset
|
148 } |
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
149 } |
1973 | 150 |
151 _pause_succeeded = | |
152 g1h->do_collection_pause_at_safepoint(_target_pause_time_ms); | |
153 if (_pause_succeeded && _word_size > 0) { | |
154 // An allocation had been requested. | |
155 _result = g1h->attempt_allocation_at_safepoint(_word_size, | |
156 true /* expect_null_cur_alloc_region */); | |
157 } else { | |
158 assert(_result == NULL, "invariant"); | |
5963
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
159 if (!_pause_succeeded) { |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
160 // Another possible reason reason for the pause to not be successful |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
161 // is that, again, the GC locker is active (and has become active |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
162 // since the prologue was executed). In this case we should retry |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
163 // the pause after waiting for the GC locker to become inactive. |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
164 _should_retry_gc = true; |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
165 } |
1973 | 166 } |
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
167 } |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
168 |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
169 void VM_G1IncCollectionPause::doit_epilogue() { |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
170 VM_GC_Operation::doit_epilogue(); |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
171 |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
172 // If the pause was initiated by a System.gc() and |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
173 // +ExplicitGCInvokesConcurrent, we have to wait here for the cycle |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
174 // that just started (or maybe one that was already in progress) to |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
175 // finish. |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
176 if (_gc_cause == GCCause::_java_lang_system_gc && |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
177 _should_initiate_conc_mark) { |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
178 assert(ExplicitGCInvokesConcurrent, |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
179 "the only way to be here is if ExplicitGCInvokesConcurrent is set"); |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
180 |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
181 G1CollectedHeap* g1h = G1CollectedHeap::heap(); |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
182 |
6120
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6062
diff
changeset
|
183 // In the doit() method we saved g1h->old_marking_cycles_completed() |
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6062
diff
changeset
|
184 // in the _old_marking_cycles_completed_before field. We have to |
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6062
diff
changeset
|
185 // wait until we observe that g1h->old_marking_cycles_completed() |
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
186 // has increased by at least one. This can happen if a) we started |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
187 // a cycle and it completes, b) a cycle already in progress |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
188 // completes, or c) a Full GC happens. |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
189 |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
190 // If the condition has already been reached, there's no point in |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
191 // actually taking the lock and doing the wait. |
6120
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6062
diff
changeset
|
192 if (g1h->old_marking_cycles_completed() <= |
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6062
diff
changeset
|
193 _old_marking_cycles_completed_before) { |
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
194 // The following is largely copied from CMS |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
195 |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
196 Thread* thr = Thread::current(); |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
197 assert(thr->is_Java_thread(), "invariant"); |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
198 JavaThread* jt = (JavaThread*)thr; |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
199 ThreadToNativeFromVM native(jt); |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
200 |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
201 MutexLockerEx x(FullGCCount_lock, Mutex::_no_safepoint_check_flag); |
6120
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6062
diff
changeset
|
202 while (g1h->old_marking_cycles_completed() <= |
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6062
diff
changeset
|
203 _old_marking_cycles_completed_before) { |
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
204 FullGCCount_lock->wait(Mutex::_no_safepoint_check_flag); |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
205 } |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
206 } |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
207 } |
342 | 208 } |
209 | |
4022
db89aa49298f
7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents:
3914
diff
changeset
|
210 void VM_CGC_Operation::acquire_pending_list_lock() { |
5963
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
211 assert(_needs_pll, "don't call this otherwise"); |
4022
db89aa49298f
7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents:
3914
diff
changeset
|
212 // The caller may block while communicating |
db89aa49298f
7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents:
3914
diff
changeset
|
213 // with the SLT thread in order to acquire/release the PLL. |
db89aa49298f
7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents:
3914
diff
changeset
|
214 ConcurrentMarkThread::slt()-> |
db89aa49298f
7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents:
3914
diff
changeset
|
215 manipulatePLL(SurrogateLockerThread::acquirePLL); |
db89aa49298f
7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents:
3914
diff
changeset
|
216 } |
db89aa49298f
7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents:
3914
diff
changeset
|
217 |
db89aa49298f
7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents:
3914
diff
changeset
|
218 void VM_CGC_Operation::release_and_notify_pending_list_lock() { |
5963
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
219 assert(_needs_pll, "don't call this otherwise"); |
4022
db89aa49298f
7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents:
3914
diff
changeset
|
220 // The caller may block while communicating |
db89aa49298f
7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents:
3914
diff
changeset
|
221 // with the SLT thread in order to acquire/release the PLL. |
db89aa49298f
7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents:
3914
diff
changeset
|
222 ConcurrentMarkThread::slt()-> |
db89aa49298f
7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents:
3914
diff
changeset
|
223 manipulatePLL(SurrogateLockerThread::releaseAndNotifyPLL); |
db89aa49298f
7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents:
3914
diff
changeset
|
224 } |
db89aa49298f
7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents:
3914
diff
changeset
|
225 |
342 | 226 void VM_CGC_Operation::doit() { |
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5963
diff
changeset
|
227 gclog_or_tty->date_stamp(G1Log::fine() && PrintGCDateStamps); |
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5963
diff
changeset
|
228 TraceCPUTime tcpu(G1Log::finer(), true, gclog_or_tty); |
10405 | 229 GCTraceTime t(_printGCMessage, G1Log::fine(), true, G1CollectedHeap::heap()->gc_timer_cm()); |
342 | 230 SharedHeap* sh = SharedHeap::heap(); |
231 // This could go away if CollectedHeap gave access to _gc_is_active... | |
232 if (sh != NULL) { | |
233 IsGCActiveMark x; | |
234 _cl->do_void(); | |
235 } else { | |
236 _cl->do_void(); | |
237 } | |
238 } | |
239 | |
240 bool VM_CGC_Operation::doit_prologue() { | |
4022
db89aa49298f
7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents:
3914
diff
changeset
|
241 // Note the relative order of the locks must match that in |
db89aa49298f
7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents:
3914
diff
changeset
|
242 // VM_GC_Operation::doit_prologue() or deadlocks can occur |
5963
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
243 if (_needs_pll) { |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
244 acquire_pending_list_lock(); |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
245 } |
4022
db89aa49298f
7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents:
3914
diff
changeset
|
246 |
342 | 247 Heap_lock->lock(); |
248 SharedHeap::heap()->_thread_holds_heap_lock_for_gc = true; | |
249 return true; | |
250 } | |
251 | |
252 void VM_CGC_Operation::doit_epilogue() { | |
4022
db89aa49298f
7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents:
3914
diff
changeset
|
253 // Note the relative order of the unlocks must match that in |
db89aa49298f
7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents:
3914
diff
changeset
|
254 // VM_GC_Operation::doit_epilogue() |
342 | 255 SharedHeap::heap()->_thread_holds_heap_lock_for_gc = false; |
256 Heap_lock->unlock(); | |
5963
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
257 if (_needs_pll) { |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
258 release_and_notify_pending_list_lock(); |
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4829
diff
changeset
|
259 } |
342 | 260 } |