author | tschatzl |
Thu, 23 Nov 2017 15:51:06 +0100 | |
changeset 48103 | 26dbe08d1c17 |
parent 47756 | 55714c3d544c |
child 49031 | e4a0cc16b050 |
permissions | -rw-r--r-- |
46384
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
1 |
/* |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
2 |
* Copyright (c) 2001, 2017, Oracle and/or its affiliates. All rights reserved. |
1374 | 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 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4022
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4022
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4022
diff
changeset
|
21 |
* questions. |
1374 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#include "precompiled.hpp" |
36084
9a3bf78e9a76
8148992: VM can hang on exit if root region scanning is initiated but not executed
brutisso
parents:
35943
diff
changeset
|
26 |
#include "classfile/classLoaderData.hpp" |
30764 | 27 |
#include "gc/g1/concurrentMarkThread.inline.hpp" |
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37129
diff
changeset
|
28 |
#include "gc/g1/g1Analytics.hpp" |
30764 | 29 |
#include "gc/g1/g1CollectedHeap.inline.hpp" |
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
30 |
#include "gc/g1/g1ConcurrentMark.inline.hpp" |
30764 | 31 |
#include "gc/g1/g1MMUTracker.hpp" |
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37414
diff
changeset
|
32 |
#include "gc/g1/g1Policy.hpp" |
30764 | 33 |
#include "gc/g1/vm_operations_g1.hpp" |
46384
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
34 |
#include "gc/shared/concurrentGCPhaseManager.hpp" |
33107
77bf0d2069a3
8134953: Make the GC ID available in a central place
brutisso
parents:
33106
diff
changeset
|
35 |
#include "gc/shared/gcId.hpp" |
30764 | 36 |
#include "gc/shared/gcTrace.hpp" |
35061 | 37 |
#include "gc/shared/gcTraceTime.inline.hpp" |
47647
64dba69fc528
8189276: Make SuspendibleThreadSet and related code available to other GCs
rkennke
parents:
47216
diff
changeset
|
38 |
#include "gc/shared/suspendibleThreadSet.hpp" |
35061 | 39 |
#include "logging/log.hpp" |
7397 | 40 |
#include "memory/resourceArea.hpp" |
41 |
#include "runtime/vmThread.hpp" |
|
46384
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
42 |
#include "utilities/debug.hpp" |
1374 | 43 |
|
44 |
// ======= Concurrent Mark Thread ======== |
|
45 |
||
46384
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
46 |
// Check order in EXPAND_CURRENT_PHASES |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
47 |
STATIC_ASSERT(ConcurrentGCPhaseManager::UNCONSTRAINED_PHASE < |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
48 |
ConcurrentGCPhaseManager::IDLE_PHASE); |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
49 |
|
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
50 |
#define EXPAND_CONCURRENT_PHASES(expander) \ |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
51 |
expander(ANY, = ConcurrentGCPhaseManager::UNCONSTRAINED_PHASE, NULL) \ |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
52 |
expander(IDLE, = ConcurrentGCPhaseManager::IDLE_PHASE, NULL) \ |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
53 |
expander(CONCURRENT_CYCLE,, "Concurrent Cycle") \ |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
54 |
expander(CLEAR_CLAIMED_MARKS,, "Concurrent Clear Claimed Marks") \ |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
55 |
expander(SCAN_ROOT_REGIONS,, "Concurrent Scan Root Regions") \ |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
56 |
expander(CONCURRENT_MARK,, "Concurrent Mark") \ |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
57 |
expander(MARK_FROM_ROOTS,, "Concurrent Mark From Roots") \ |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
58 |
expander(BEFORE_REMARK,, NULL) \ |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
59 |
expander(REMARK,, NULL) \ |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
60 |
expander(CREATE_LIVE_DATA,, "Concurrent Create Live Data") \ |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
61 |
expander(COMPLETE_CLEANUP,, "Concurrent Complete Cleanup") \ |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
62 |
expander(CLEANUP_FOR_NEXT_MARK,, "Concurrent Cleanup for Next Mark") \ |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
63 |
/* */ |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
64 |
|
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
65 |
class G1ConcurrentPhase : public AllStatic { |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
66 |
public: |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
67 |
enum { |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
68 |
#define CONCURRENT_PHASE_ENUM(tag, value, ignore_title) tag value, |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
69 |
EXPAND_CONCURRENT_PHASES(CONCURRENT_PHASE_ENUM) |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
70 |
#undef CONCURRENT_PHASE_ENUM |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
71 |
PHASE_ID_LIMIT |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
72 |
}; |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
73 |
}; |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
74 |
|
1374 | 75 |
// The CM thread is created when the G1 garbage collector is used |
76 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35204
diff
changeset
|
77 |
ConcurrentMarkThread::ConcurrentMarkThread(G1ConcurrentMark* cm) : |
1374 | 78 |
ConcurrentGCThread(), |
79 |
_cm(cm), |
|
31597
f63dde8cc8f7
8129626: G1: set_in_progress() and clear_started() needs a barrier on non-TSO platforms
brutisso
parents:
31397
diff
changeset
|
80 |
_state(Idle), |
46384
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
81 |
_phase_manager_stack(), |
1374 | 82 |
_vtime_accum(0.0), |
11583
83a7383de44c
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
11175
diff
changeset
|
83 |
_vtime_mark_accum(0.0) { |
24331
c0bc7e5653fb
6885993: Named Thread: introduce print() and print_on(outputStream* st) methods
zgu
parents:
24094
diff
changeset
|
84 |
|
29464
02c245ad3ec9
8073545: Use shorter and more descriptive names for GC worker threads
david
parents:
27885
diff
changeset
|
85 |
set_name("G1 Main Marker"); |
1374 | 86 |
create_and_start(); |
87 |
} |
|
88 |
||
89 |
class CMCheckpointRootsFinalClosure: public VoidClosure { |
|
90 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35204
diff
changeset
|
91 |
G1ConcurrentMark* _cm; |
1374 | 92 |
public: |
93 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35204
diff
changeset
|
94 |
CMCheckpointRootsFinalClosure(G1ConcurrentMark* cm) : |
1374 | 95 |
_cm(cm) {} |
96 |
||
97 |
void do_void(){ |
|
47678 | 98 |
_cm->checkpoint_roots_final(false); // !clear_all_soft_refs |
1374 | 99 |
} |
100 |
}; |
|
101 |
||
102 |
class CMCleanUp: public VoidClosure { |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35204
diff
changeset
|
103 |
G1ConcurrentMark* _cm; |
1374 | 104 |
public: |
105 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35204
diff
changeset
|
106 |
CMCleanUp(G1ConcurrentMark* cm) : |
1374 | 107 |
_cm(cm) {} |
108 |
||
109 |
void do_void(){ |
|
110 |
_cm->cleanup(); |
|
111 |
} |
|
112 |
}; |
|
113 |
||
47756
55714c3d544c
8185278: TestGreyReclaimedHumongousObjects.java fails guarantee(index != trim_index(_head_index + 1)) failed: should not go past head
sangheki
parents:
47678
diff
changeset
|
114 |
double ConcurrentMarkThread::mmu_sleep_time(G1Policy* g1_policy, bool remark) { |
55714c3d544c
8185278: TestGreyReclaimedHumongousObjects.java fails guarantee(index != trim_index(_head_index + 1)) failed: should not go past head
sangheki
parents:
47678
diff
changeset
|
115 |
// There are 3 reasons to use SuspendibleThreadSetJoiner. |
55714c3d544c
8185278: TestGreyReclaimedHumongousObjects.java fails guarantee(index != trim_index(_head_index + 1)) failed: should not go past head
sangheki
parents:
47678
diff
changeset
|
116 |
// 1. To avoid concurrency problem. |
55714c3d544c
8185278: TestGreyReclaimedHumongousObjects.java fails guarantee(index != trim_index(_head_index + 1)) failed: should not go past head
sangheki
parents:
47678
diff
changeset
|
117 |
// - G1MMUTracker::add_pause(), when_sec() and its variation(when_ms() etc..) can be called |
55714c3d544c
8185278: TestGreyReclaimedHumongousObjects.java fails guarantee(index != trim_index(_head_index + 1)) failed: should not go past head
sangheki
parents:
47678
diff
changeset
|
118 |
// concurrently from ConcurrentMarkThread and VMThread. |
55714c3d544c
8185278: TestGreyReclaimedHumongousObjects.java fails guarantee(index != trim_index(_head_index + 1)) failed: should not go past head
sangheki
parents:
47678
diff
changeset
|
119 |
// 2. If currently a gc is running, but it has not yet updated the MMU, |
55714c3d544c
8185278: TestGreyReclaimedHumongousObjects.java fails guarantee(index != trim_index(_head_index + 1)) failed: should not go past head
sangheki
parents:
47678
diff
changeset
|
120 |
// we will not forget to consider that pause in the MMU calculation. |
55714c3d544c
8185278: TestGreyReclaimedHumongousObjects.java fails guarantee(index != trim_index(_head_index + 1)) failed: should not go past head
sangheki
parents:
47678
diff
changeset
|
121 |
// 3. If currently a gc is running, ConcurrentMarkThread will wait it to be finished. |
55714c3d544c
8185278: TestGreyReclaimedHumongousObjects.java fails guarantee(index != trim_index(_head_index + 1)) failed: should not go past head
sangheki
parents:
47678
diff
changeset
|
122 |
// And then sleep for predicted amount of time by delay_to_keep_mmu(). |
55714c3d544c
8185278: TestGreyReclaimedHumongousObjects.java fails guarantee(index != trim_index(_head_index + 1)) failed: should not go past head
sangheki
parents:
47678
diff
changeset
|
123 |
SuspendibleThreadSetJoiner sts_join; |
55714c3d544c
8185278: TestGreyReclaimedHumongousObjects.java fails guarantee(index != trim_index(_head_index + 1)) failed: should not go past head
sangheki
parents:
47678
diff
changeset
|
124 |
|
55714c3d544c
8185278: TestGreyReclaimedHumongousObjects.java fails guarantee(index != trim_index(_head_index + 1)) failed: should not go past head
sangheki
parents:
47678
diff
changeset
|
125 |
const G1Analytics* analytics = g1_policy->analytics(); |
55714c3d544c
8185278: TestGreyReclaimedHumongousObjects.java fails guarantee(index != trim_index(_head_index + 1)) failed: should not go past head
sangheki
parents:
47678
diff
changeset
|
126 |
double now = os::elapsedTime(); |
55714c3d544c
8185278: TestGreyReclaimedHumongousObjects.java fails guarantee(index != trim_index(_head_index + 1)) failed: should not go past head
sangheki
parents:
47678
diff
changeset
|
127 |
double prediction_ms = remark ? analytics->predict_remark_time_ms() |
55714c3d544c
8185278: TestGreyReclaimedHumongousObjects.java fails guarantee(index != trim_index(_head_index + 1)) failed: should not go past head
sangheki
parents:
47678
diff
changeset
|
128 |
: analytics->predict_cleanup_time_ms(); |
55714c3d544c
8185278: TestGreyReclaimedHumongousObjects.java fails guarantee(index != trim_index(_head_index + 1)) failed: should not go past head
sangheki
parents:
47678
diff
changeset
|
129 |
G1MMUTracker *mmu_tracker = g1_policy->mmu_tracker(); |
55714c3d544c
8185278: TestGreyReclaimedHumongousObjects.java fails guarantee(index != trim_index(_head_index + 1)) failed: should not go past head
sangheki
parents:
47678
diff
changeset
|
130 |
return mmu_tracker->when_ms(now, prediction_ms); |
55714c3d544c
8185278: TestGreyReclaimedHumongousObjects.java fails guarantee(index != trim_index(_head_index + 1)) failed: should not go past head
sangheki
parents:
47678
diff
changeset
|
131 |
} |
55714c3d544c
8185278: TestGreyReclaimedHumongousObjects.java fails guarantee(index != trim_index(_head_index + 1)) failed: should not go past head
sangheki
parents:
47678
diff
changeset
|
132 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37414
diff
changeset
|
133 |
void ConcurrentMarkThread::delay_to_keep_mmu(G1Policy* g1_policy, bool remark) { |
33608
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
134 |
if (g1_policy->adaptive_young_list_length()) { |
47756
55714c3d544c
8185278: TestGreyReclaimedHumongousObjects.java fails guarantee(index != trim_index(_head_index + 1)) failed: should not go past head
sangheki
parents:
47678
diff
changeset
|
135 |
jlong sleep_time_ms = mmu_sleep_time(g1_policy, remark); |
55714c3d544c
8185278: TestGreyReclaimedHumongousObjects.java fails guarantee(index != trim_index(_head_index + 1)) failed: should not go past head
sangheki
parents:
47678
diff
changeset
|
136 |
if (!cm()->has_aborted() && sleep_time_ms > 0) { |
55714c3d544c
8185278: TestGreyReclaimedHumongousObjects.java fails guarantee(index != trim_index(_head_index + 1)) failed: should not go past head
sangheki
parents:
47678
diff
changeset
|
137 |
os::sleep(this, sleep_time_ms, false); |
55714c3d544c
8185278: TestGreyReclaimedHumongousObjects.java fails guarantee(index != trim_index(_head_index + 1)) failed: should not go past head
sangheki
parents:
47678
diff
changeset
|
138 |
} |
33608
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
139 |
} |
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
140 |
} |
35204 | 141 |
|
37123
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
142 |
class G1ConcPhaseTimer : public GCTraceConcTimeImpl<LogLevel::Info, LOG_TAGS(gc, marking)> { |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35204
diff
changeset
|
143 |
G1ConcurrentMark* _cm; |
35204 | 144 |
|
145 |
public: |
|
37123
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
146 |
G1ConcPhaseTimer(G1ConcurrentMark* cm, const char* title) : |
46384
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
147 |
GCTraceConcTimeImpl<LogLevel::Info, LogTag::_gc, LogTag::_marking>(title), |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
148 |
_cm(cm) |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
149 |
{ |
37137
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37134
diff
changeset
|
150 |
_cm->gc_timer_cm()->register_gc_concurrent_start(title); |
35204 | 151 |
} |
152 |
||
37123
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
153 |
~G1ConcPhaseTimer() { |
37137
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37134
diff
changeset
|
154 |
_cm->gc_timer_cm()->register_gc_concurrent_end(); |
35204 | 155 |
} |
156 |
}; |
|
157 |
||
46384
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
158 |
static const char* const concurrent_phase_names[] = { |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
159 |
#define CONCURRENT_PHASE_NAME(tag, ignore_value, ignore_title) XSTR(tag), |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
160 |
EXPAND_CONCURRENT_PHASES(CONCURRENT_PHASE_NAME) |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
161 |
#undef CONCURRENT_PHASE_NAME |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
162 |
NULL // terminator |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
163 |
}; |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
164 |
// Verify dense enum assumption. +1 for terminator. |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
165 |
STATIC_ASSERT(G1ConcurrentPhase::PHASE_ID_LIMIT + 1 == |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
166 |
ARRAY_SIZE(concurrent_phase_names)); |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
167 |
|
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
168 |
// Returns the phase number for name, or a negative value if unknown. |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
169 |
static int lookup_concurrent_phase(const char* name) { |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
170 |
const char* const* names = concurrent_phase_names; |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
171 |
for (uint i = 0; names[i] != NULL; ++i) { |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
172 |
if (strcmp(name, names[i]) == 0) { |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
173 |
return static_cast<int>(i); |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
174 |
} |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
175 |
} |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
176 |
return -1; |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
177 |
} |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
178 |
|
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
179 |
// The phase must be valid and must have a title. |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
180 |
static const char* lookup_concurrent_phase_title(int phase) { |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
181 |
static const char* const titles[] = { |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
182 |
#define CONCURRENT_PHASE_TITLE(ignore_tag, ignore_value, title) title, |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
183 |
EXPAND_CONCURRENT_PHASES(CONCURRENT_PHASE_TITLE) |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
184 |
#undef CONCURRENT_PHASE_TITLE |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
185 |
}; |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
186 |
// Verify dense enum assumption. |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
187 |
STATIC_ASSERT(G1ConcurrentPhase::PHASE_ID_LIMIT == ARRAY_SIZE(titles)); |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
188 |
|
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
189 |
assert(0 <= phase, "precondition"); |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
190 |
assert((uint)phase < ARRAY_SIZE(titles), "precondition"); |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
191 |
const char* title = titles[phase]; |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
192 |
assert(title != NULL, "precondition"); |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
193 |
return title; |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
194 |
} |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
195 |
|
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
196 |
class G1ConcPhaseManager : public StackObj { |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
197 |
G1ConcurrentMark* _cm; |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
198 |
ConcurrentGCPhaseManager _manager; |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
199 |
|
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
200 |
public: |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
201 |
G1ConcPhaseManager(int phase, ConcurrentMarkThread* thread) : |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
202 |
_cm(thread->cm()), |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
203 |
_manager(phase, thread->phase_manager_stack()) |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
204 |
{ } |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
205 |
|
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
206 |
~G1ConcPhaseManager() { |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
207 |
// Deactivate the manager if marking aborted, to avoid blocking on |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
208 |
// phase exit when the phase has been requested. |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
209 |
if (_cm->has_aborted()) { |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
210 |
_manager.deactivate(); |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
211 |
} |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
212 |
} |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
213 |
|
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
214 |
void set_phase(int phase, bool force) { |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
215 |
_manager.set_phase(phase, force); |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
216 |
} |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
217 |
}; |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
218 |
|
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
219 |
// Combine phase management and timing into one convenient utility. |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
220 |
class G1ConcPhase : public StackObj { |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
221 |
G1ConcPhaseTimer _timer; |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
222 |
G1ConcPhaseManager _manager; |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
223 |
|
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
224 |
public: |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
225 |
G1ConcPhase(int phase, ConcurrentMarkThread* thread) : |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
226 |
_timer(thread->cm(), lookup_concurrent_phase_title(phase)), |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
227 |
_manager(phase, thread) |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
228 |
{ } |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
229 |
}; |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
230 |
|
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
231 |
const char* const* ConcurrentMarkThread::concurrent_phases() const { |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
232 |
return concurrent_phase_names; |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
233 |
} |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
234 |
|
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
235 |
bool ConcurrentMarkThread::request_concurrent_phase(const char* phase_name) { |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
236 |
int phase = lookup_concurrent_phase(phase_name); |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
237 |
if (phase < 0) return false; |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
238 |
|
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
239 |
while (!ConcurrentGCPhaseManager::wait_for_phase(phase, |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
240 |
phase_manager_stack())) { |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
241 |
assert(phase != G1ConcurrentPhase::ANY, "Wait for ANY phase must succeed"); |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
242 |
if ((phase != G1ConcurrentPhase::IDLE) && !during_cycle()) { |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
243 |
// If idle and the goal is !idle, start a collection. |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
244 |
G1CollectedHeap::heap()->collect(GCCause::_wb_conc_mark); |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
245 |
} |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
246 |
} |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
247 |
return true; |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
248 |
} |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
249 |
|
33608
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
250 |
void ConcurrentMarkThread::run_service() { |
1374 | 251 |
_vtime_start = os::elapsedVTime(); |
252 |
||
7923 | 253 |
G1CollectedHeap* g1h = G1CollectedHeap::heap(); |
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37414
diff
changeset
|
254 |
G1Policy* g1_policy = g1h->g1_policy(); |
1374 | 255 |
|
46384
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
256 |
G1ConcPhaseManager cpmanager(G1ConcurrentPhase::IDLE, this); |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
257 |
|
37081
7656f5356a5d
8140257: Add support for "gc service threads" to ConcurrentGCThread
drwhite
parents:
36084
diff
changeset
|
258 |
while (!should_terminate()) { |
1374 | 259 |
// wait until started is set. |
260 |
sleepBeforeNextCycle(); |
|
37081
7656f5356a5d
8140257: Add support for "gc service threads" to ConcurrentGCThread
drwhite
parents:
36084
diff
changeset
|
261 |
if (should_terminate()) { |
24093
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
262 |
break; |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
263 |
} |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
264 |
|
46384
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
265 |
cpmanager.set_phase(G1ConcurrentPhase::CONCURRENT_CYCLE, false /* force */); |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
266 |
|
37137
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37134
diff
changeset
|
267 |
GCIdMark gc_id_mark; |
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37134
diff
changeset
|
268 |
|
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37134
diff
changeset
|
269 |
cm()->concurrent_cycle_start(); |
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37134
diff
changeset
|
270 |
|
33152
6ad7fe735042
8139293: TestGCEventMixedWithG1ConcurrentMark.java fails after JDK-8134953
brutisso
parents:
33107
diff
changeset
|
271 |
assert(GCId::current() != GCId::undefined(), "GC id should have been set up by the initial mark GC."); |
37123
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
272 |
|
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
273 |
GCTraceConcTime(Info, gc) tt("Concurrent Cycle"); |
1374 | 274 |
{ |
275 |
ResourceMark rm; |
|
276 |
HandleMark hm; |
|
277 |
double cycle_start = os::elapsedVTime(); |
|
278 |
||
36084
9a3bf78e9a76
8148992: VM can hang on exit if root region scanning is initiated but not executed
brutisso
parents:
35943
diff
changeset
|
279 |
{ |
46384
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
280 |
G1ConcPhase p(G1ConcurrentPhase::CLEAR_CLAIMED_MARKS, this); |
36084
9a3bf78e9a76
8148992: VM can hang on exit if root region scanning is initiated but not executed
brutisso
parents:
35943
diff
changeset
|
281 |
ClassLoaderDataGraph::clear_claimed_marks(); |
9a3bf78e9a76
8148992: VM can hang on exit if root region scanning is initiated but not executed
brutisso
parents:
35943
diff
changeset
|
282 |
} |
9a3bf78e9a76
8148992: VM can hang on exit if root region scanning is initiated but not executed
brutisso
parents:
35943
diff
changeset
|
283 |
|
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
284 |
// We have to ensure that we finish scanning the root regions |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
285 |
// before the next GC takes place. To ensure this we have to |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
286 |
// make sure that we do not join the STS until the root regions |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
287 |
// have been scanned. If we did then it's possible that a |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
288 |
// subsequent GC could block us from joining the STS and proceed |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
289 |
// without the root regions have been scanned which would be a |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
290 |
// correctness issue. |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
291 |
|
36084
9a3bf78e9a76
8148992: VM can hang on exit if root region scanning is initiated but not executed
brutisso
parents:
35943
diff
changeset
|
292 |
{ |
46384
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
293 |
G1ConcPhase p(G1ConcurrentPhase::SCAN_ROOT_REGIONS, this); |
37123
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
294 |
_cm->scan_root_regions(); |
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
295 |
} |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
296 |
|
46384
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
297 |
// It would be nice to use the G1ConcPhase class here but |
35061 | 298 |
// the "end" logging is inside the loop and not at the end of |
46384
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
299 |
// a scope. Also, the timer doesn't support nesting. |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
300 |
// Mimicking the same log output instead. |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
301 |
{ |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
302 |
G1ConcPhaseManager mark_manager(G1ConcurrentPhase::CONCURRENT_MARK, this); |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
303 |
jlong mark_start = os::elapsed_counter(); |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
304 |
const char* cm_title = |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
305 |
lookup_concurrent_phase_title(G1ConcurrentPhase::CONCURRENT_MARK); |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
306 |
log_info(gc, marking)("%s (%.3fs)", |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
307 |
cm_title, |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
308 |
TimeHelper::counter_to_seconds(mark_start)); |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
309 |
for (uint iter = 1; !cm()->has_aborted(); ++iter) { |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
310 |
// Concurrent marking. |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
311 |
{ |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
312 |
G1ConcPhase p(G1ConcurrentPhase::MARK_FROM_ROOTS, this); |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
313 |
_cm->mark_from_roots(); |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
314 |
} |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
315 |
if (cm()->has_aborted()) break; |
1374 | 316 |
|
46384
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
317 |
// Provide a control point after mark_from_roots. |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
318 |
{ |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
319 |
G1ConcPhaseManager p(G1ConcurrentPhase::BEFORE_REMARK, this); |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
320 |
} |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
321 |
if (cm()->has_aborted()) break; |
1374 | 322 |
|
46384
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
323 |
// Delay remark pause for MMU. |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
324 |
double mark_end_time = os::elapsedVTime(); |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
325 |
jlong mark_end = os::elapsed_counter(); |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
326 |
_vtime_mark_accum += (mark_end_time - cycle_start); |
33608
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
327 |
delay_to_keep_mmu(g1_policy, true /* remark */); |
46384
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
328 |
if (cm()->has_aborted()) break; |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
329 |
|
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
330 |
// Pause Remark. |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
331 |
log_info(gc, marking)("%s (%.3fs, %.3fs) %.3fms", |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
332 |
cm_title, |
37123
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
333 |
TimeHelper::counter_to_seconds(mark_start), |
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
334 |
TimeHelper::counter_to_seconds(mark_end), |
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
335 |
TimeHelper::counter_to_millis(mark_end - mark_start)); |
46384
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
336 |
mark_manager.set_phase(G1ConcurrentPhase::REMARK, false); |
1374 | 337 |
CMCheckpointRootsFinalClosure final_cl(_cm); |
40892
330a02d935ad
8156500: Move Reference pending list into VM to prevent deadlocks
kbarrett
parents:
37985
diff
changeset
|
338 |
VM_CGC_Operation op(&final_cl, "Pause Remark"); |
1374 | 339 |
VMThread::execute(&op); |
46384
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
340 |
if (cm()->has_aborted()) { |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
341 |
break; |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
342 |
} else if (!cm()->restart_for_overflow()) { |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
343 |
break; // Exit loop if no restart requested. |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
344 |
} else { |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
345 |
// Loop to restart for overflow. |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
346 |
mark_manager.set_phase(G1ConcurrentPhase::CONCURRENT_MARK, false); |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
347 |
log_info(gc, marking)("%s Restart for Mark Stack Overflow (iteration #%u)", |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
348 |
cm_title, iter); |
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
349 |
} |
1374 | 350 |
} |
42570
5a4f3339b5d9
8169423: Infinite loop in G1's ConcurrentMarkThread
kbarrett
parents:
40892
diff
changeset
|
351 |
} |
10769
983d377770fd
7099824: G1: we should take the pending list lock before doing the remark pause
johnc
parents:
10745
diff
changeset
|
352 |
|
37413
2f71679d06dd
8077144: Concurrent mark initialization takes too long
tschatzl
parents:
37137
diff
changeset
|
353 |
if (!cm()->has_aborted()) { |
46384
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
354 |
G1ConcPhase p(G1ConcurrentPhase::CREATE_LIVE_DATA, this); |
37413
2f71679d06dd
8077144: Concurrent mark initialization takes too long
tschatzl
parents:
37137
diff
changeset
|
355 |
cm()->create_live_data(); |
2f71679d06dd
8077144: Concurrent mark initialization takes too long
tschatzl
parents:
37137
diff
changeset
|
356 |
} |
2f71679d06dd
8077144: Concurrent mark initialization takes too long
tschatzl
parents:
37137
diff
changeset
|
357 |
|
1374 | 358 |
double end_time = os::elapsedVTime(); |
359 |
// Update the total virtual time before doing this, since it will try |
|
360 |
// to measure it to get the vtime for this marking. We purposely |
|
361 |
// neglect the presumably-short "completeCleanup" phase here. |
|
362 |
_vtime_accum = (end_time - _vtime_start); |
|
11583
83a7383de44c
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
11175
diff
changeset
|
363 |
|
1374 | 364 |
if (!cm()->has_aborted()) { |
33608
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
365 |
delay_to_keep_mmu(g1_policy, false /* cleanup */); |
1374 | 366 |
|
47756
55714c3d544c
8185278: TestGreyReclaimedHumongousObjects.java fails guarantee(index != trim_index(_head_index + 1)) failed: should not go past head
sangheki
parents:
47678
diff
changeset
|
367 |
if (!cm()->has_aborted()) { |
55714c3d544c
8185278: TestGreyReclaimedHumongousObjects.java fails guarantee(index != trim_index(_head_index + 1)) failed: should not go past head
sangheki
parents:
47678
diff
changeset
|
368 |
CMCleanUp cl_cl(_cm); |
55714c3d544c
8185278: TestGreyReclaimedHumongousObjects.java fails guarantee(index != trim_index(_head_index + 1)) failed: should not go past head
sangheki
parents:
47678
diff
changeset
|
369 |
VM_CGC_Operation op(&cl_cl, "Pause Cleanup"); |
55714c3d544c
8185278: TestGreyReclaimedHumongousObjects.java fails guarantee(index != trim_index(_head_index + 1)) failed: should not go past head
sangheki
parents:
47678
diff
changeset
|
370 |
VMThread::execute(&op); |
55714c3d544c
8185278: TestGreyReclaimedHumongousObjects.java fails guarantee(index != trim_index(_head_index + 1)) failed: should not go past head
sangheki
parents:
47678
diff
changeset
|
371 |
} |
1374 | 372 |
} else { |
11175
7fde26aecbe5
7114303: G1: assert(_g1->mark_in_progress()) failed: shouldn't be here otherwise
johnc
parents:
10769
diff
changeset
|
373 |
// We don't want to update the marking status if a GC pause |
7fde26aecbe5
7114303: G1: assert(_g1->mark_in_progress()) failed: shouldn't be here otherwise
johnc
parents:
10769
diff
changeset
|
374 |
// is already underway. |
30613
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
29464
diff
changeset
|
375 |
SuspendibleThreadSetJoiner sts_join; |
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30770
diff
changeset
|
376 |
g1h->collector_state()->set_mark_in_progress(false); |
1374 | 377 |
} |
378 |
||
7923 | 379 |
// Check if cleanup set the free_regions_coming flag. If it |
380 |
// hasn't, we can just skip the next step. |
|
381 |
if (g1h->free_regions_coming()) { |
|
382 |
// The following will finish freeing up any regions that we |
|
383 |
// found to be empty during cleanup. We'll do this part |
|
384 |
// without joining the suspendible set. If an evacuation pause |
|
8680 | 385 |
// takes place, then we would carry on freeing regions in |
7923 | 386 |
// case they are needed by the pause. If a Full GC takes |
8680 | 387 |
// place, it would wait for us to process the regions |
7923 | 388 |
// reclaimed by cleanup. |
389 |
||
10745
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
390 |
// Now do the concurrent cleanup operation. |
46384
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
391 |
G1ConcPhase p(G1ConcurrentPhase::COMPLETE_CLEANUP, this); |
37123
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
392 |
_cm->complete_cleanup(); |
10745
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
393 |
|
8100 | 394 |
// Notify anyone who's waiting that there are no more free |
10745
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
395 |
// regions coming. We have to do this before we join the STS |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
396 |
// (in fact, we should not attempt to join the STS in the |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
397 |
// interval between finishing the cleanup pause and clearing |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
398 |
// the free_regions_coming flag) otherwise we might deadlock: |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
399 |
// a GC worker could be blocked waiting for the notification |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
400 |
// whereas this thread will be blocked for the pause to finish |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
401 |
// while it's trying to join the STS, which is conditional on |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
402 |
// the GC workers finishing. |
8100 | 403 |
g1h->reset_free_regions_coming(); |
1374 | 404 |
} |
7923 | 405 |
guarantee(cm()->cleanup_list_is_empty(), |
406 |
"at this point there should be no regions on the cleanup list"); |
|
1374 | 407 |
|
10745
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
408 |
// There is a tricky race before recording that the concurrent |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
409 |
// cleanup has completed and a potential Full GC starting around |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
410 |
// the same time. We want to make sure that the Full GC calls |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
411 |
// abort() on concurrent mark after |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
412 |
// record_concurrent_mark_cleanup_completed(), since abort() is |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
413 |
// the method that will reset the concurrent mark state. If we |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
414 |
// end up calling record_concurrent_mark_cleanup_completed() |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
415 |
// after abort() then we might incorrectly undo some of the work |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
416 |
// abort() did. Checking the has_aborted() flag after joining |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
417 |
// the STS allows the correct ordering of the two methods. There |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
418 |
// are two scenarios: |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
419 |
// |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
420 |
// a) If we reach here before the Full GC, the fact that we have |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
421 |
// joined the STS means that the Full GC cannot start until we |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
422 |
// leave the STS, so record_concurrent_mark_cleanup_completed() |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
423 |
// will complete before abort() is called. |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
424 |
// |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
425 |
// b) If we reach here during the Full GC, we'll be held up from |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
426 |
// joining the STS until the Full GC is done, which means that |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
427 |
// abort() will have completed and has_aborted() will return |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
428 |
// true to prevent us from calling |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
429 |
// record_concurrent_mark_cleanup_completed() (and, in fact, it's |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
430 |
// not needed any more as the concurrent mark state has been |
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
431 |
// already reset). |
24094 | 432 |
{ |
30613
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
29464
diff
changeset
|
433 |
SuspendibleThreadSetJoiner sts_join; |
24094 | 434 |
if (!cm()->has_aborted()) { |
435 |
g1_policy->record_concurrent_mark_cleanup_completed(); |
|
31397
c9cc3289b80c
8129549: G1: Make sure the concurrent thread does not mix its logging with the STW pauses
brutisso
parents:
31331
diff
changeset
|
436 |
} else { |
37123
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
437 |
log_info(gc, marking)("Concurrent Mark Abort"); |
1374 | 438 |
} |
439 |
} |
|
440 |
||
10745
6b33ec421509
7098085: G1: partially-young GCs not initiated under certain circumstances
tonyp
parents:
10280
diff
changeset
|
441 |
// We now want to allow clearing of the marking bitmap to be |
1374 | 442 |
// suspended by a collection pause. |
25728
7f8a76e3baa8
8048085: Aborting marking just before remark results in useless additional clearing of the next mark bitmap
tschatzl
parents:
25350
diff
changeset
|
443 |
// We may have aborted just before the remark. Do not bother clearing the |
7f8a76e3baa8
8048085: Aborting marking just before remark results in useless additional clearing of the next mark bitmap
tschatzl
parents:
25350
diff
changeset
|
444 |
// bitmap then, as it has been done during mark abort. |
7f8a76e3baa8
8048085: Aborting marking just before remark results in useless additional clearing of the next mark bitmap
tschatzl
parents:
25350
diff
changeset
|
445 |
if (!cm()->has_aborted()) { |
46384
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
446 |
G1ConcPhase p(G1ConcurrentPhase::CLEANUP_FOR_NEXT_MARK, this); |
37122
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37081
diff
changeset
|
447 |
_cm->cleanup_for_next_mark(); |
25728
7f8a76e3baa8
8048085: Aborting marking just before remark results in useless additional clearing of the next mark bitmap
tschatzl
parents:
25350
diff
changeset
|
448 |
} else { |
47678 | 449 |
assert(!G1VerifyBitmaps || _cm->next_mark_bitmap_is_clear(), "Next mark bitmap must be clear"); |
24094 | 450 |
} |
1374 | 451 |
} |
6058
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5547
diff
changeset
|
452 |
|
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5547
diff
changeset
|
453 |
// Update the number of full collections that have been |
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5547
diff
changeset
|
454 |
// completed. This will also notify the FullGCCount_lock in case a |
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5547
diff
changeset
|
455 |
// Java thread is waiting for a full GC to happen (e.g., it |
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5547
diff
changeset
|
456 |
// called System.gc() with +ExplicitGCInvokesConcurrent). |
24094 | 457 |
{ |
30613
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
29464
diff
changeset
|
458 |
SuspendibleThreadSetJoiner sts_join; |
24094 | 459 |
g1h->increment_old_marking_cycles_completed(true /* concurrent */); |
37137
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37134
diff
changeset
|
460 |
|
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37134
diff
changeset
|
461 |
cm()->concurrent_cycle_end(); |
24094 | 462 |
} |
46384
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
463 |
|
dacebddcdea0
8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents:
42570
diff
changeset
|
464 |
cpmanager.set_phase(G1ConcurrentPhase::IDLE, cm()->has_aborted() /* force */); |
1374 | 465 |
} |
37120
7f2e805b6b77
8151336: Root region scanning should be cancelled and disabled when the ConcurrentMarkThread::run_service() exits
brutisso
parents:
37081
diff
changeset
|
466 |
_cm->root_regions()->cancel_scan(); |
1374 | 467 |
} |
468 |
||
33608
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
469 |
void ConcurrentMarkThread::stop_service() { |
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
470 |
MutexLockerEx ml(CGC_lock, Mutex::_no_safepoint_check_flag); |
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
471 |
CGC_lock->notify_all(); |
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
472 |
} |
7afc768e4d62
8138920: Refactor the sampling thread from ConcurrentG1RefineThread
drwhite
parents:
33152
diff
changeset
|
473 |
|
1374 | 474 |
void ConcurrentMarkThread::sleepBeforeNextCycle() { |
475 |
// We join here because we don't want to do the "shouldConcurrentMark()" |
|
476 |
// below while the world is otherwise stopped. |
|
6766
839211600ad0
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
6058
diff
changeset
|
477 |
assert(!in_progress(), "should have been cleared"); |
839211600ad0
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
6058
diff
changeset
|
478 |
|
1374 | 479 |
MutexLockerEx x(CGC_lock, Mutex::_no_safepoint_check_flag); |
37081
7656f5356a5d
8140257: Add support for "gc service threads" to ConcurrentGCThread
drwhite
parents:
36084
diff
changeset
|
480 |
while (!started() && !should_terminate()) { |
1374 | 481 |
CGC_lock->wait(Mutex::_no_safepoint_check_flag); |
482 |
} |
|
24093
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
483 |
|
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
484 |
if (started()) { |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
485 |
set_in_progress(); |
095cc0a63ed9
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
18025
diff
changeset
|
486 |
} |
1374 | 487 |
} |