Mercurial > hg > truffle

annotate src/share/vm/gc_implementation/g1/vm_operations_g1.cpp @ 4155:394404b2d9bd

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Removed strict requirement for GRAAL environment variable. It only needs to be set now if the graal directory is not in the directory hierarchy of GraalVM JDK.
author Doug Simon <doug.simon@oracle.com>
date Wed, 21 Dec 2011 11:25:27 +0100
parents db89aa49298f
children 9509c20bba28
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1 /*
2426
1d1603768966 7010070: Update all 2010 Oracle-changed OpenJDK files to have the proper copyright dates - second pass
trims
parents: 2125
diff changeset
2 * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved.
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4 *
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
5 * This code is free software; you can redistribute it and/or modify it
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
6 * under the terms of the GNU General Public License version 2 only, as
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
7 * published by the Free Software Foundation.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
8 *
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
9 * This code is distributed in the hope that it will be useful, but WITHOUT
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
12 * version 2 for more details (a copy is included in the LICENSE file that
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
13 * accompanied this code).
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
14 *
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
15 * You should have received a copy of the GNU General Public License version
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
16 * 2 along with this work; if not, write to the Free Software Foundation,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
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
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
22 *
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
23 */
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
24
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1656
diff changeset
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
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1656
diff changeset
27 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1656
diff changeset
28 #include "gc_implementation/g1/g1CollectorPolicy.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1656
diff changeset
29 #include "gc_implementation/g1/vm_operations_g1.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1656
diff changeset
30 #include "gc_implementation/shared/isGCActiveMark.hpp"
1973
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
31 #include "gc_implementation/g1/vm_operations_g1.hpp"
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1656
diff changeset
32 #include "runtime/interfaceSupport.hpp"
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
33
1973
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
34 VM_G1CollectForAllocation::VM_G1CollectForAllocation(
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
35 unsigned int gc_count_before,
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
36 size_t word_size)
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
37 : VM_G1OperationWithAllocRequest(gc_count_before, word_size) {
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
38 guarantee(word_size > 0, "an allocation should always be requested");
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
39 }
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
40
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
41 void VM_G1CollectForAllocation::doit() {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
42 G1CollectedHeap* g1h = G1CollectedHeap::heap();
1973
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
43 _result = g1h->satisfy_failed_allocation(_word_size, &_pause_succeeded);
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
44 assert(_result == NULL || _pause_succeeded,
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
45 "if we get back a result, the pause should have succeeded");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
46 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
47
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
48 void VM_G1CollectFull::doit() {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
49 G1CollectedHeap* g1h = G1CollectedHeap::heap();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
50 GCCauseSetter x(g1h, _gc_cause);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
51 g1h->do_full_collection(false /* clear_all_soft_refs */);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
52 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
53
1973
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
54 VM_G1IncCollectionPause::VM_G1IncCollectionPause(
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
55 unsigned int gc_count_before,
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
56 size_t word_size,
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
57 bool should_initiate_conc_mark,
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
58 double target_pause_time_ms,
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
59 GCCause::Cause gc_cause)
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
60 : VM_G1OperationWithAllocRequest(gc_count_before, word_size),
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
61 _should_initiate_conc_mark(should_initiate_conc_mark),
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
62 _target_pause_time_ms(target_pause_time_ms),
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
63 _full_collections_completed_before(0) {
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
64 guarantee(target_pause_time_ms > 0.0,
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
65 err_msg("target_pause_time_ms = %1.6lf should be positive",
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
66 target_pause_time_ms));
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
67 guarantee(word_size == 0 || gc_cause == GCCause::_g1_inc_collection_pause,
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
68 "we can only request an allocation if the GC cause is for "
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
69 "an incremental GC pause");
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
70 _gc_cause = gc_cause;
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
71 }
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
72
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
73 void VM_G1IncCollectionPause::doit() {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
74 G1CollectedHeap* g1h = G1CollectedHeap::heap();
1656
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
75 assert(!_should_initiate_conc_mark ||
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
76 ((_gc_cause == GCCause::_gc_locker && GCLockerInvokesConcurrent) ||
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
77 (_gc_cause == GCCause::_java_lang_system_gc && ExplicitGCInvokesConcurrent)),
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
78 "only a GC locker or a System.gc() induced GC should start a cycle");
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
79
1973
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
80 if (_word_size > 0) {
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
81 // An allocation has been requested. So, try to do that first.
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
82 _result = g1h->attempt_allocation_at_safepoint(_word_size,
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
83 false /* expect_null_cur_alloc_region */);
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
84 if (_result != NULL) {
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
85 // If we can successfully allocate before we actually do the
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
86 // pause then we will consider this pause successful.
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
87 _pause_succeeded = true;
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
88 return;
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
89 }
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
90 }
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
91
1088
3fc996d4edd2 6902303: G1: ScavengeALot should cause an incremental, rather than a full, collection
ysr
parents: 844
diff changeset
92 GCCauseSetter x(g1h, _gc_cause);
1656
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
93 if (_should_initiate_conc_mark) {
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
94 // It's safer to read full_collections_completed() here, given
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
95 // 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
96 // 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
97 // setting it earlier.
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
98 _full_collections_completed_before = g1h->full_collections_completed();
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
99
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
100 // 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
101 // 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
102 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
103
5130fa1b24f1 7045751: G1: +ExplicitGCInvokesConcurrent causes excessive single region evacuation pauses
johnc
parents: 2426
diff changeset
104 // 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
105 // 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
106 // marking cycle is already in progress.
5130fa1b24f1 7045751: G1: +ExplicitGCInvokesConcurrent causes excessive single region evacuation pauses
johnc
parents: 2426
diff changeset
107 //
5130fa1b24f1 7045751: G1: +ExplicitGCInvokesConcurrent causes excessive single region evacuation pauses
johnc
parents: 2426
diff changeset
108 // If a marking cycle is already in progress just return and skip
5130fa1b24f1 7045751: G1: +ExplicitGCInvokesConcurrent causes excessive single region evacuation pauses
johnc
parents: 2426
diff changeset
109 // the pause - the requesting thread should block in doit_epilogue
5130fa1b24f1 7045751: G1: +ExplicitGCInvokesConcurrent causes excessive single region evacuation pauses
johnc
parents: 2426
diff changeset
110 // until the marking cycle is complete.
5130fa1b24f1 7045751: G1: +ExplicitGCInvokesConcurrent causes excessive single region evacuation pauses
johnc
parents: 2426
diff changeset
111 if (!res) {
5130fa1b24f1 7045751: G1: +ExplicitGCInvokesConcurrent causes excessive single region evacuation pauses
johnc
parents: 2426
diff changeset
112 assert(_word_size == 0, "ExplicitGCInvokesConcurrent shouldn't be allocating");
5130fa1b24f1 7045751: G1: +ExplicitGCInvokesConcurrent causes excessive single region evacuation pauses
johnc
parents: 2426
diff changeset
113 return;
5130fa1b24f1 7045751: G1: +ExplicitGCInvokesConcurrent causes excessive single region evacuation pauses
johnc
parents: 2426
diff changeset
114 }
1656
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
115 }
1973
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
116
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
117 _pause_succeeded =
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
118 g1h->do_collection_pause_at_safepoint(_target_pause_time_ms);
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
119 if (_pause_succeeded && _word_size > 0) {
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
120 // An allocation had been requested.
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
121 _result = g1h->attempt_allocation_at_safepoint(_word_size,
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
122 true /* expect_null_cur_alloc_region */);
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
123 } else {
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
124 assert(_result == NULL, "invariant");
631f79e71e90 6974966: G1: unnecessary direct-to-old allocations
tonyp
parents: 1972
diff changeset
125 }
1656
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
126 }
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
127
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
128 void VM_G1IncCollectionPause::doit_epilogue() {
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
129 VM_GC_Operation::doit_epilogue();
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
130
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
131 // 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
132 // +ExplicitGCInvokesConcurrent, we have to wait here for the cycle
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
133 // 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
134 // finish.
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
135 if (_gc_cause == GCCause::_java_lang_system_gc &&
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
136 _should_initiate_conc_mark) {
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
137 assert(ExplicitGCInvokesConcurrent,
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
138 "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
139
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
140 G1CollectedHeap* g1h = G1CollectedHeap::heap();
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
141
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
142 // In the doit() method we saved g1h->full_collections_completed()
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
143 // in the _full_collections_completed_before field. We have to
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
144 // wait until we observe that g1h->full_collections_completed()
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
145 // 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
146 // 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
147 // completes, or c) a Full GC happens.
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
148
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
149 // 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
150 // actually taking the lock and doing the wait.
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
151 if (g1h->full_collections_completed() <=
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
152 _full_collections_completed_before) {
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
153 // The following is largely copied from CMS
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
154
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
155 Thread* thr = Thread::current();
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
156 assert(thr->is_Java_thread(), "invariant");
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
157 JavaThread* jt = (JavaThread*)thr;
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
158 ThreadToNativeFromVM native(jt);
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
159
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
160 MutexLockerEx x(FullGCCount_lock, Mutex::_no_safepoint_check_flag);
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
161 while (g1h->full_collections_completed() <=
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
162 _full_collections_completed_before) {
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
163 FullGCCount_lock->wait(Mutex::_no_safepoint_check_flag);
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
164 }
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
165 }
4e5661ba9d98 6944166: G1: explicit GCs are not always handled correctly
tonyp
parents: 1552
diff changeset
166 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
167 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
168
4022
db89aa49298f 7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents: 3914
diff changeset
169 void VM_CGC_Operation::acquire_pending_list_lock() {
db89aa49298f 7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents: 3914
diff changeset
170 // 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
171 // 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
172 ConcurrentMarkThread::slt()->
db89aa49298f 7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents: 3914
diff changeset
173 manipulatePLL(SurrogateLockerThread::acquirePLL);
db89aa49298f 7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents: 3914
diff changeset
174 }
db89aa49298f 7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents: 3914
diff changeset
175
db89aa49298f 7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents: 3914
diff changeset
176 void VM_CGC_Operation::release_and_notify_pending_list_lock() {
db89aa49298f 7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents: 3914
diff changeset
177 // 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
178 // 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
179 ConcurrentMarkThread::slt()->
db89aa49298f 7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents: 3914
diff changeset
180 manipulatePLL(SurrogateLockerThread::releaseAndNotifyPLL);
db89aa49298f 7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents: 3914
diff changeset
181 }
db89aa49298f 7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents: 3914
diff changeset
182
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
183 void VM_CGC_Operation::doit() {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
184 gclog_or_tty->date_stamp(PrintGC && PrintGCDateStamps);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
185 TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
186 TraceTime t(_printGCMessage, PrintGC, true, gclog_or_tty);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
187 SharedHeap* sh = SharedHeap::heap();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
188 // This could go away if CollectedHeap gave access to _gc_is_active...
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
189 if (sh != NULL) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
190 IsGCActiveMark x;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
191 _cl->do_void();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
192 } else {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
193 _cl->do_void();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
194 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
195 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
196
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
197 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
198 // 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
199 // VM_GC_Operation::doit_prologue() or deadlocks can occur
db89aa49298f 7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents: 3914
diff changeset
200 acquire_pending_list_lock();
db89aa49298f 7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents: 3914
diff changeset
201
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
202 Heap_lock->lock();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
203 SharedHeap::heap()->_thread_holds_heap_lock_for_gc = true;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
204 return true;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
205 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
206
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
207 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
208 // 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
209 // VM_GC_Operation::doit_epilogue()
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
210 SharedHeap::heap()->_thread_holds_heap_lock_for_gc = false;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
211 Heap_lock->unlock();
4022
db89aa49298f 7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents: 3914
diff changeset
212 release_and_notify_pending_list_lock();
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
213 }