author | rehn |
Fri, 29 Nov 2019 12:09:25 +0100 | |
changeset 59325 | 3636bab5e81e |
parent 59290 | 97d13893ec3c |
permissions | -rw-r--r-- |
1 | 1 |
/* |
53582 | 2 |
* Copyright (c) 1998, 2019, Oracle and/or its affiliates. All rights reserved. |
1 | 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:
5403
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5403
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:
5403
diff
changeset
|
21 |
* questions. |
1 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#include "precompiled.hpp" |
26 |
#include "compiler/compileBroker.hpp" |
|
30764 | 27 |
#include "gc/shared/collectedHeap.hpp" |
50113 | 28 |
#include "jfr/jfrEvents.hpp" |
29 |
#include "jfr/support/jfrThreadId.hpp" |
|
46732
05423d4b10d2
8185273: Test8004741.java crashes with SIGSEGV in JDK10-hs nightly
dcubed
parents:
46589
diff
changeset
|
30 |
#include "logging/log.hpp" |
53020
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
31 |
#include "logging/logStream.hpp" |
46732
05423d4b10d2
8185273: Test8004741.java crashes with SIGSEGV in JDK10-hs nightly
dcubed
parents:
46589
diff
changeset
|
32 |
#include "logging/logConfiguration.hpp" |
7397 | 33 |
#include "memory/resourceArea.hpp" |
54786 | 34 |
#include "memory/universe.hpp" |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
35 |
#include "oops/method.hpp" |
7397 | 36 |
#include "oops/oop.inline.hpp" |
29084
1b732f2836ce
8073387: Move VerifyOopClosures out from genOopClosures.hpp
stefank
parents:
28163
diff
changeset
|
37 |
#include "oops/verifyOopClosure.hpp" |
59290
97d13893ec3c
8234748: Clean up atomic and orderAccess includes
stefank
parents:
59247
diff
changeset
|
38 |
#include "runtime/atomic.hpp" |
53582 | 39 |
#include "runtime/handles.inline.hpp" |
49449
ef5d5d343e2a
8199263: Split interfaceSupport.hpp to not require including .inline.hpp files
coleenp
parents:
47216
diff
changeset
|
40 |
#include "runtime/interfaceSupport.inline.hpp" |
7397 | 41 |
#include "runtime/mutexLocker.hpp" |
42 |
#include "runtime/os.hpp" |
|
37176
663bdc7d0b86
8149023: Event based tracing should cover safepoint begin and end
dsimms
parents:
36384
diff
changeset
|
43 |
#include "runtime/safepoint.hpp" |
14583
d70ee55535f4
8003935: Simplify the needed includes for using Thread::current()
stefank
parents:
14582
diff
changeset
|
44 |
#include "runtime/thread.inline.hpp" |
7397 | 45 |
#include "runtime/vmThread.hpp" |
52877
9e041366c764
8214850: Rename vm_operations.?pp files to vmOperations.?pp files
tschatzl
parents:
52386
diff
changeset
|
46 |
#include "runtime/vmOperations.hpp" |
7397 | 47 |
#include "services/runtimeService.hpp" |
48 |
#include "utilities/dtrace.hpp" |
|
49 |
#include "utilities/events.hpp" |
|
46589 | 50 |
#include "utilities/vmError.hpp" |
7397 | 51 |
#include "utilities/xmlstream.hpp" |
1 | 52 |
|
59325 | 53 |
VM_QueueHead VMOperationQueue::_queue_head[VMOperationQueue::nof_priorities]; |
54 |
||
1 | 55 |
VMOperationQueue::VMOperationQueue() { |
56 |
// The queue is a circular doubled-linked list, which always contains |
|
57 |
// one element (i.e., one element means empty). |
|
58 |
for(int i = 0; i < nof_priorities; i++) { |
|
59 |
_queue_length[i] = 0; |
|
60 |
_queue_counter = 0; |
|
59325 | 61 |
_queue[i] = &_queue_head[i]; |
1 | 62 |
_queue[i]->set_next(_queue[i]); |
63 |
_queue[i]->set_prev(_queue[i]); |
|
64 |
} |
|
65 |
_drain_list = NULL; |
|
66 |
} |
|
67 |
||
68 |
||
69 |
bool VMOperationQueue::queue_empty(int prio) { |
|
70 |
// It is empty if there is exactly one element |
|
71 |
bool empty = (_queue[prio] == _queue[prio]->next()); |
|
72 |
assert( (_queue_length[prio] == 0 && empty) || |
|
73 |
(_queue_length[prio] > 0 && !empty), "sanity check"); |
|
74 |
return _queue_length[prio] == 0; |
|
75 |
} |
|
76 |
||
77 |
// Inserts an element to the right of the q element |
|
78 |
void VMOperationQueue::insert(VM_Operation* q, VM_Operation* n) { |
|
79 |
assert(q->next()->prev() == q && q->prev()->next() == q, "sanity check"); |
|
80 |
n->set_prev(q); |
|
81 |
n->set_next(q->next()); |
|
82 |
q->next()->set_prev(n); |
|
83 |
q->set_next(n); |
|
84 |
} |
|
85 |
||
59325 | 86 |
void VMOperationQueue::queue_add(int prio, VM_Operation *op) { |
1 | 87 |
_queue_length[prio]++; |
88 |
insert(_queue[prio]->prev(), op); |
|
89 |
} |
|
90 |
||
91 |
||
92 |
void VMOperationQueue::unlink(VM_Operation* q) { |
|
93 |
assert(q->next()->prev() == q && q->prev()->next() == q, "sanity check"); |
|
94 |
q->prev()->set_next(q->next()); |
|
95 |
q->next()->set_prev(q->prev()); |
|
96 |
} |
|
97 |
||
98 |
VM_Operation* VMOperationQueue::queue_remove_front(int prio) { |
|
99 |
if (queue_empty(prio)) return NULL; |
|
100 |
assert(_queue_length[prio] >= 0, "sanity check"); |
|
101 |
_queue_length[prio]--; |
|
102 |
VM_Operation* r = _queue[prio]->next(); |
|
103 |
assert(r != _queue[prio], "cannot remove base element"); |
|
104 |
unlink(r); |
|
105 |
return r; |
|
106 |
} |
|
107 |
||
108 |
VM_Operation* VMOperationQueue::queue_drain(int prio) { |
|
109 |
if (queue_empty(prio)) return NULL; |
|
110 |
DEBUG_ONLY(int length = _queue_length[prio];); |
|
111 |
assert(length >= 0, "sanity check"); |
|
112 |
_queue_length[prio] = 0; |
|
113 |
VM_Operation* r = _queue[prio]->next(); |
|
114 |
assert(r != _queue[prio], "cannot remove base element"); |
|
115 |
// remove links to base element from head and tail |
|
116 |
r->set_prev(NULL); |
|
117 |
_queue[prio]->prev()->set_next(NULL); |
|
118 |
// restore queue to empty state |
|
119 |
_queue[prio]->set_next(_queue[prio]); |
|
120 |
_queue[prio]->set_prev(_queue[prio]); |
|
5402
c51fd0c1d005
6888953: some calls to function-like macros are missing semicolons
jcoomes
parents:
5089
diff
changeset
|
121 |
assert(queue_empty(prio), "drain corrupted queue"); |
17006 | 122 |
#ifdef ASSERT |
1 | 123 |
int len = 0; |
124 |
VM_Operation* cur; |
|
125 |
for(cur = r; cur != NULL; cur=cur->next()) len++; |
|
126 |
assert(len == length, "drain lost some ops"); |
|
127 |
#endif |
|
128 |
return r; |
|
129 |
} |
|
130 |
||
131 |
void VMOperationQueue::queue_oops_do(int queue, OopClosure* f) { |
|
132 |
VM_Operation* cur = _queue[queue]; |
|
133 |
cur = cur->next(); |
|
134 |
while (cur != _queue[queue]) { |
|
135 |
cur->oops_do(f); |
|
136 |
cur = cur->next(); |
|
137 |
} |
|
138 |
} |
|
139 |
||
140 |
void VMOperationQueue::drain_list_oops_do(OopClosure* f) { |
|
141 |
VM_Operation* cur = _drain_list; |
|
142 |
while (cur != NULL) { |
|
143 |
cur->oops_do(f); |
|
144 |
cur = cur->next(); |
|
145 |
} |
|
146 |
} |
|
147 |
||
148 |
//----------------------------------------------------------------- |
|
149 |
// High-level interface |
|
55128
35192d9c2b76
8225016: Dead code due to VMOperationQueue::add() always returning true
pchilanomate
parents:
54786
diff
changeset
|
150 |
void VMOperationQueue::add(VM_Operation *op) { |
5089
0cce506a0158
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
4901
diff
changeset
|
151 |
|
10739 | 152 |
HOTSPOT_VMOPS_REQUEST( |
153 |
(char *) op->name(), strlen(op->name()), |
|
59325 | 154 |
op->evaluate_at_safepoint() ? 0 : 1); |
5089
0cce506a0158
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
4901
diff
changeset
|
155 |
|
1 | 156 |
// Encapsulates VM queue policy. Currently, that |
157 |
// only involves putting them on the right list |
|
59325 | 158 |
queue_add(op->evaluate_at_safepoint() ? SafepointPriority : MediumPriority, op); |
1 | 159 |
} |
160 |
||
161 |
VM_Operation* VMOperationQueue::remove_next() { |
|
162 |
// Assuming VMOperation queue is two-level priority queue. If there are |
|
163 |
// more than two priorities, we need a different scheduling algorithm. |
|
164 |
assert(SafepointPriority == 0 && MediumPriority == 1 && nof_priorities == 2, |
|
165 |
"current algorithm does not work"); |
|
166 |
||
167 |
// simple counter based scheduling to prevent starvation of lower priority |
|
168 |
// queue. -- see 4390175 |
|
169 |
int high_prio, low_prio; |
|
170 |
if (_queue_counter++ < 10) { |
|
171 |
high_prio = SafepointPriority; |
|
172 |
low_prio = MediumPriority; |
|
173 |
} else { |
|
174 |
_queue_counter = 0; |
|
175 |
high_prio = MediumPriority; |
|
176 |
low_prio = SafepointPriority; |
|
177 |
} |
|
178 |
||
179 |
return queue_remove_front(queue_empty(high_prio) ? low_prio : high_prio); |
|
180 |
} |
|
181 |
||
182 |
void VMOperationQueue::oops_do(OopClosure* f) { |
|
183 |
for(int i = 0; i < nof_priorities; i++) { |
|
184 |
queue_oops_do(i, f); |
|
185 |
} |
|
186 |
drain_list_oops_do(f); |
|
187 |
} |
|
188 |
||
53020
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
189 |
//------------------------------------------------------------------------------------------------------------------ |
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
190 |
// Timeout machinery |
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
191 |
|
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
192 |
void VMOperationTimeoutTask::task() { |
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
193 |
assert(AbortVMOnVMOperationTimeout, "only if enabled"); |
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
194 |
if (is_armed()) { |
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
195 |
jlong delay = (os::javaTimeMillis() - _arm_time); |
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
196 |
if (delay > AbortVMOnVMOperationTimeoutDelay) { |
53051
d4da64e0e916
8215374: 32-bit build failures after JDK-8181143 (Introduce diagnostic flag to abort VM on too long VM operations)
shade
parents:
53020
diff
changeset
|
197 |
fatal("VM operation took too long: " JLONG_FORMAT " ms (timeout: " INTX_FORMAT " ms)", |
53020
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
198 |
delay, AbortVMOnVMOperationTimeoutDelay); |
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
199 |
} |
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
200 |
} |
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
201 |
} |
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
202 |
|
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
203 |
bool VMOperationTimeoutTask::is_armed() { |
59247
56bf71d64d51
8234562: Move OrderAccess::release_store*/load_acquire to Atomic
stefank
parents:
58409
diff
changeset
|
204 |
return Atomic::load_acquire(&_armed) != 0; |
53020
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
205 |
} |
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
206 |
|
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
207 |
void VMOperationTimeoutTask::arm() { |
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
208 |
_arm_time = os::javaTimeMillis(); |
59247
56bf71d64d51
8234562: Move OrderAccess::release_store*/load_acquire to Atomic
stefank
parents:
58409
diff
changeset
|
209 |
Atomic::release_store_fence(&_armed, 1); |
53020
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
210 |
} |
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
211 |
|
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
212 |
void VMOperationTimeoutTask::disarm() { |
59247
56bf71d64d51
8234562: Move OrderAccess::release_store*/load_acquire to Atomic
stefank
parents:
58409
diff
changeset
|
213 |
Atomic::release_store_fence(&_armed, 0); |
53020
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
214 |
} |
1 | 215 |
|
216 |
//------------------------------------------------------------------------------------------------------------------ |
|
217 |
// Implementation of VMThread stuff |
|
218 |
||
53895 | 219 |
bool VMThread::_should_terminate = false; |
1 | 220 |
bool VMThread::_terminated = false; |
221 |
Monitor* VMThread::_terminate_lock = NULL; |
|
222 |
VMThread* VMThread::_vm_thread = NULL; |
|
223 |
VM_Operation* VMThread::_cur_vm_operation = NULL; |
|
224 |
VMOperationQueue* VMThread::_vm_queue = NULL; |
|
225 |
PerfCounter* VMThread::_perf_accumulated_vm_operation_time = NULL; |
|
53895 | 226 |
uint64_t VMThread::_coalesced_count = 0; |
53020
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
227 |
VMOperationTimeoutTask* VMThread::_timeout_task = NULL; |
1 | 228 |
|
229 |
||
230 |
void VMThread::create() { |
|
231 |
assert(vm_thread() == NULL, "we can only allocate one VMThread"); |
|
232 |
_vm_thread = new VMThread(); |
|
233 |
||
53020
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
234 |
if (AbortVMOnVMOperationTimeout) { |
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
235 |
// Make sure we call the timeout task frequently enough, but not too frequent. |
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
236 |
// Try to make the interval 10% of the timeout delay, so that we miss the timeout |
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
237 |
// by those 10% at max. Periodic task also expects it to fit min/max intervals. |
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
238 |
size_t interval = (size_t)AbortVMOnVMOperationTimeoutDelay / 10; |
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
239 |
interval = interval / PeriodicTask::interval_gran * PeriodicTask::interval_gran; |
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
240 |
interval = MAX2<size_t>(interval, PeriodicTask::min_interval); |
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
241 |
interval = MIN2<size_t>(interval, PeriodicTask::max_interval); |
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
242 |
|
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
243 |
_timeout_task = new VMOperationTimeoutTask(interval); |
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
244 |
_timeout_task->enroll(); |
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
245 |
} else { |
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
246 |
assert(_timeout_task == NULL, "sanity"); |
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
247 |
} |
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
248 |
|
1 | 249 |
// Create VM operation queue |
250 |
_vm_queue = new VMOperationQueue(); |
|
251 |
guarantee(_vm_queue != NULL, "just checking"); |
|
252 |
||
28163
322d55d167be
8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents:
27164
diff
changeset
|
253 |
_terminate_lock = new Monitor(Mutex::safepoint, "VMThread::_terminate_lock", true, |
322d55d167be
8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents:
27164
diff
changeset
|
254 |
Monitor::_safepoint_check_never); |
1 | 255 |
|
256 |
if (UsePerfData) { |
|
257 |
// jvmstat performance counters |
|
258 |
Thread* THREAD = Thread::current(); |
|
259 |
_perf_accumulated_vm_operation_time = |
|
260 |
PerfDataManager::create_counter(SUN_THREADS, "vmOperationTime", |
|
261 |
PerfData::U_Ticks, CHECK); |
|
262 |
} |
|
263 |
} |
|
264 |
||
4489
514173c9a0c2
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
3908
diff
changeset
|
265 |
VMThread::VMThread() : NamedThread() { |
514173c9a0c2
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
3908
diff
changeset
|
266 |
set_name("VM Thread"); |
1 | 267 |
} |
268 |
||
269 |
void VMThread::destroy() { |
|
38290
6b194cfc1557
8154715: Missing destructor and/or TLS clearing calls for terminating threads
dholmes
parents:
38074
diff
changeset
|
270 |
_vm_thread = NULL; // VM thread is gone |
1 | 271 |
} |
272 |
||
53895 | 273 |
static VM_None halt_op("Halt"); |
274 |
||
1 | 275 |
void VMThread::run() { |
276 |
assert(this == vm_thread(), "check"); |
|
277 |
||
278 |
// Notify_lock wait checks on active_handles() to rewait in |
|
279 |
// case of spurious wakeup, it should wait on the last |
|
280 |
// value set prior to the notify |
|
281 |
this->set_active_handles(JNIHandleBlock::allocate_block()); |
|
282 |
||
283 |
{ |
|
284 |
MutexLocker ml(Notify_lock); |
|
285 |
Notify_lock->notify(); |
|
286 |
} |
|
287 |
// Notify_lock is destroyed by Threads::create_vm() |
|
288 |
||
289 |
int prio = (VMThreadPriority == -1) |
|
290 |
? os::java_to_os_priority[NearMaxPriority] |
|
291 |
: VMThreadPriority; |
|
292 |
// Note that I cannot call os::set_priority because it expects Java |
|
293 |
// priorities and I am *explicitly* using OS priorities so that it's |
|
294 |
// possible to set the VM thread priority higher than any Java thread. |
|
295 |
os::set_native_priority( this, prio ); |
|
296 |
||
297 |
// Wait for VM_Operations until termination |
|
298 |
this->loop(); |
|
299 |
||
300 |
// Note the intention to exit before safepointing. |
|
301 |
// 6295565 This has the effect of waiting for any large tty |
|
302 |
// outputs to finish. |
|
303 |
if (xtty != NULL) { |
|
304 |
ttyLocker ttyl; |
|
305 |
xtty->begin_elem("destroy_vm"); |
|
306 |
xtty->stamp(); |
|
307 |
xtty->end_elem(); |
|
308 |
assert(should_terminate(), "termination flag must be set"); |
|
309 |
} |
|
310 |
||
311 |
// 4526887 let VM thread exit at Safepoint |
|
53895 | 312 |
_cur_vm_operation = &halt_op; |
1 | 313 |
SafepointSynchronize::begin(); |
314 |
||
315 |
if (VerifyBeforeExit) { |
|
316 |
HandleMark hm(VMThread::vm_thread()); |
|
317 |
// Among other things, this ensures that Eden top is correct. |
|
318 |
Universe::heap()->prepare_for_verify(); |
|
9342
456b8d0486b5
7039089: G1: changeset for 7037276 broke heap verification, and related cleanups
ysr
parents:
7397
diff
changeset
|
319 |
// Silent verification so as not to pollute normal output, |
456b8d0486b5
7039089: G1: changeset for 7037276 broke heap verification, and related cleanups
ysr
parents:
7397
diff
changeset
|
320 |
// unless we really asked for it. |
35061 | 321 |
Universe::verify(); |
1 | 322 |
} |
323 |
||
324 |
CompileBroker::set_should_block(); |
|
325 |
||
326 |
// wait for threads (compiler threads or daemon threads) in the |
|
327 |
// _thread_in_native state to block. |
|
328 |
VM_Exit::wait_for_threads_in_native_to_block(); |
|
329 |
||
330 |
// signal other threads that VM process is gone |
|
331 |
{ |
|
332 |
// Note: we must have the _no_safepoint_check_flag. Mutex::lock() allows |
|
333 |
// VM thread to enter any lock at Safepoint as long as its _owner is NULL. |
|
334 |
// If that happens after _terminate_lock->wait() has unset _owner |
|
335 |
// but before it actually drops the lock and waits, the notification below |
|
336 |
// may get lost and we will have a hang. To avoid this, we need to use |
|
337 |
// Mutex::lock_without_safepoint_check(). |
|
54645
05aaccf7d558
8222988: Use MonitorLocker rather than MutexLocker when wait/notify used
coleenp
parents:
54623
diff
changeset
|
338 |
MonitorLocker ml(_terminate_lock, Mutex::_no_safepoint_check_flag); |
1 | 339 |
_terminated = true; |
54645
05aaccf7d558
8222988: Use MonitorLocker rather than MutexLocker when wait/notify used
coleenp
parents:
54623
diff
changeset
|
340 |
ml.notify(); |
1 | 341 |
} |
342 |
||
38290
6b194cfc1557
8154715: Missing destructor and/or TLS clearing calls for terminating threads
dholmes
parents:
38074
diff
changeset
|
343 |
// We are now racing with the VM termination being carried out in |
6b194cfc1557
8154715: Missing destructor and/or TLS clearing calls for terminating threads
dholmes
parents:
38074
diff
changeset
|
344 |
// another thread, so we don't "delete this". Numerous threads don't |
6b194cfc1557
8154715: Missing destructor and/or TLS clearing calls for terminating threads
dholmes
parents:
38074
diff
changeset
|
345 |
// get deleted when the VM terminates |
1 | 346 |
|
347 |
} |
|
348 |
||
349 |
||
350 |
// Notify the VMThread that the last non-daemon JavaThread has terminated, |
|
351 |
// and wait until operation is performed. |
|
352 |
void VMThread::wait_for_vm_thread_exit() { |
|
52386
e256b3b62e20
8213236: A partial removed/deleted JavaThread cannot transition
rehn
parents:
52302
diff
changeset
|
353 |
assert(Thread::current()->is_Java_thread(), "Should be a JavaThread"); |
e256b3b62e20
8213236: A partial removed/deleted JavaThread cannot transition
rehn
parents:
52302
diff
changeset
|
354 |
assert(((JavaThread*)Thread::current())->is_terminated(), "Should be terminated"); |
58409
a595e67d6683
8184732: Deadlock detection improvements for 'special' locks
coleenp
parents:
58291
diff
changeset
|
355 |
{ MonitorLocker mu(VMOperationQueue_lock, Mutex::_no_safepoint_check_flag); |
1 | 356 |
_should_terminate = true; |
58409
a595e67d6683
8184732: Deadlock detection improvements for 'special' locks
coleenp
parents:
58291
diff
changeset
|
357 |
mu.notify(); |
1 | 358 |
} |
359 |
||
360 |
// Note: VM thread leaves at Safepoint. We are not stopped by Safepoint |
|
361 |
// because this thread has been removed from the threads list. But anything |
|
362 |
// that could get blocked by Safepoint should not be used after this point, |
|
363 |
// otherwise we will hang, since there is no one can end the safepoint. |
|
364 |
||
365 |
// Wait until VM thread is terminated |
|
366 |
// Note: it should be OK to use Terminator_lock here. But this is called |
|
367 |
// at a very delicate time (VM shutdown) and we are operating in non- VM |
|
368 |
// thread at Safepoint. It's safer to not share lock with other threads. |
|
54645
05aaccf7d558
8222988: Use MonitorLocker rather than MutexLocker when wait/notify used
coleenp
parents:
54623
diff
changeset
|
369 |
{ MonitorLocker ml(_terminate_lock, Mutex::_no_safepoint_check_flag); |
1 | 370 |
while(!VMThread::is_terminated()) { |
54645
05aaccf7d558
8222988: Use MonitorLocker rather than MutexLocker when wait/notify used
coleenp
parents:
54623
diff
changeset
|
371 |
ml.wait(); |
1 | 372 |
} |
373 |
} |
|
374 |
} |
|
375 |
||
50113 | 376 |
static void post_vm_operation_event(EventExecuteVMOperation* event, VM_Operation* op) { |
377 |
assert(event != NULL, "invariant"); |
|
378 |
assert(event->should_commit(), "invariant"); |
|
379 |
assert(op != NULL, "invariant"); |
|
380 |
const bool evaluate_at_safepoint = op->evaluate_at_safepoint(); |
|
381 |
event->set_operation(op->type()); |
|
382 |
event->set_safepoint(evaluate_at_safepoint); |
|
59325 | 383 |
event->set_blocking(true); |
384 |
event->set_caller(JFR_THREAD_ID(op->calling_thread())); |
|
55514
03468b206457
8225702: Safepoint counter can't be used for safepoint detection
rehn
parents:
55128
diff
changeset
|
385 |
event->set_safepointId(evaluate_at_safepoint ? SafepointSynchronize::safepoint_id() : 0); |
50113 | 386 |
event->commit(); |
387 |
} |
|
388 |
||
1 | 389 |
void VMThread::evaluate_operation(VM_Operation* op) { |
390 |
ResourceMark rm; |
|
391 |
||
392 |
{ |
|
393 |
PerfTraceTime vm_op_timer(perf_accumulated_vm_operation_time()); |
|
10739 | 394 |
HOTSPOT_VMOPS_BEGIN( |
395 |
(char *) op->name(), strlen(op->name()), |
|
59325 | 396 |
op->evaluate_at_safepoint() ? 0 : 1); |
18025 | 397 |
|
398 |
EventExecuteVMOperation event; |
|
1 | 399 |
op->evaluate(); |
18025 | 400 |
if (event.should_commit()) { |
50113 | 401 |
post_vm_operation_event(&event, op); |
18025 | 402 |
} |
403 |
||
10739 | 404 |
HOTSPOT_VMOPS_END( |
405 |
(char *) op->name(), strlen(op->name()), |
|
59325 | 406 |
op->evaluate_at_safepoint() ? 0 : 1); |
1 | 407 |
} |
408 |
||
409 |
// Mark as completed |
|
59325 | 410 |
op->calling_thread()->increment_vm_operation_completed_count(); |
1 | 411 |
} |
412 |
||
53895 | 413 |
static VM_None safepointALot_op("SafepointALot"); |
414 |
static VM_Cleanup cleanup_op; |
|
415 |
||
54278 | 416 |
class HandshakeALotTC : public ThreadClosure { |
417 |
public: |
|
418 |
virtual void do_thread(Thread* thread) { |
|
419 |
#ifdef ASSERT |
|
420 |
assert(thread->is_Java_thread(), "must be"); |
|
421 |
JavaThread* jt = (JavaThread*)thread; |
|
422 |
jt->verify_states_for_handshake(); |
|
423 |
#endif |
|
424 |
} |
|
425 |
}; |
|
426 |
||
59325 | 427 |
void VMThread::check_for_forced_cleanup() { |
428 |
MonitorLocker mq(VMOperationQueue_lock, Mutex::_no_safepoint_check_flag); |
|
429 |
mq.notify(); |
|
430 |
} |
|
431 |
||
54278 | 432 |
VM_Operation* VMThread::no_op_safepoint() { |
433 |
// Check for handshakes first since we may need to return a VMop. |
|
434 |
if (HandshakeALot) { |
|
435 |
HandshakeALotTC haltc; |
|
436 |
Handshake::execute(&haltc); |
|
437 |
} |
|
438 |
// Check for a cleanup before SafepointALot to keep stats correct. |
|
439 |
long interval_ms = SafepointTracing::time_since_last_safepoint_ms(); |
|
440 |
bool max_time_exceeded = GuaranteedSafepointInterval != 0 && |
|
441 |
(interval_ms >= GuaranteedSafepointInterval); |
|
59325 | 442 |
if ((max_time_exceeded && SafepointSynchronize::is_cleanup_needed()) || |
443 |
SafepointSynchronize::is_forced_cleanup_needed()) { |
|
54278 | 444 |
return &cleanup_op; |
445 |
} |
|
46496 | 446 |
if (SafepointALot) { |
53895 | 447 |
return &safepointALot_op; |
46496 | 448 |
} |
54278 | 449 |
// Nothing to be done. |
450 |
return NULL; |
|
46496 | 451 |
} |
1 | 452 |
|
453 |
void VMThread::loop() { |
|
454 |
assert(_cur_vm_operation == NULL, "no current one should be executing"); |
|
455 |
||
53775 | 456 |
SafepointSynchronize::init(_vm_thread); |
457 |
||
1 | 458 |
while(true) { |
459 |
VM_Operation* safepoint_ops = NULL; |
|
460 |
// |
|
461 |
// Wait for VM operation |
|
462 |
// |
|
463 |
// use no_safepoint_check to get lock without attempting to "sneak" |
|
54645
05aaccf7d558
8222988: Use MonitorLocker rather than MutexLocker when wait/notify used
coleenp
parents:
54623
diff
changeset
|
464 |
{ MonitorLocker mu_queue(VMOperationQueue_lock, |
05aaccf7d558
8222988: Use MonitorLocker rather than MutexLocker when wait/notify used
coleenp
parents:
54623
diff
changeset
|
465 |
Mutex::_no_safepoint_check_flag); |
1 | 466 |
|
467 |
// Look for new operation |
|
468 |
assert(_cur_vm_operation == NULL, "no current one should be executing"); |
|
469 |
_cur_vm_operation = _vm_queue->remove_next(); |
|
470 |
||
471 |
// Stall time tracking code |
|
59325 | 472 |
if (PrintVMQWaitTime && _cur_vm_operation != NULL) { |
1 | 473 |
long stall = os::javaTimeMillis() - _cur_vm_operation->timestamp(); |
474 |
if (stall > 0) |
|
33148
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33105
diff
changeset
|
475 |
tty->print_cr("%s stall: %ld", _cur_vm_operation->name(), stall); |
1 | 476 |
} |
477 |
||
478 |
while (!should_terminate() && _cur_vm_operation == NULL) { |
|
479 |
// wait with a timeout to guarantee safepoints at regular intervals |
|
59325 | 480 |
// (if there is cleanup work to do) |
481 |
(void)mu_queue.wait(GuaranteedSafepointInterval); |
|
1 | 482 |
|
483 |
// Support for self destruction |
|
46589 | 484 |
if ((SelfDestructTimer != 0) && !VMError::is_error_reported() && |
33222
e0a340f4ab6e
8078556: Runtime: implement ranges (optionally constraints) for those flags that have them missing.
gziemski
parents:
33148
diff
changeset
|
485 |
(os::elapsedTime() > (double)SelfDestructTimer * 60.0)) { |
1 | 486 |
tty->print_cr("VM self-destructed"); |
487 |
exit(-1); |
|
488 |
} |
|
489 |
||
59325 | 490 |
// If the queue contains a safepoint VM op, |
491 |
// clean up will be done so we can skip this part. |
|
492 |
if (!_vm_queue->peek_at_safepoint_priority()) { |
|
493 |
||
54278 | 494 |
// Have to unlock VMOperationQueue_lock just in case no_op_safepoint() |
59325 | 495 |
// has to do a handshake when HandshakeALot is enabled. |
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54278
diff
changeset
|
496 |
MutexUnlocker mul(VMOperationQueue_lock, Mutex::_no_safepoint_check_flag); |
54278 | 497 |
if ((_cur_vm_operation = VMThread::no_op_safepoint()) != NULL) { |
498 |
// Force a safepoint since we have not had one for at least |
|
499 |
// 'GuaranteedSafepointInterval' milliseconds and we need to clean |
|
500 |
// something. This will run all the clean-up processing that needs |
|
501 |
// to be done at a safepoint. |
|
502 |
SafepointSynchronize::begin(); |
|
503 |
#ifdef ASSERT |
|
1 | 504 |
if (GCALotAtAllSafepoints) InterfaceSupport::check_gc_alot(); |
54278 | 505 |
#endif |
506 |
SafepointSynchronize::end(); |
|
507 |
_cur_vm_operation = NULL; |
|
508 |
} |
|
1 | 509 |
} |
510 |
_cur_vm_operation = _vm_queue->remove_next(); |
|
511 |
||
512 |
// If we are at a safepoint we will evaluate all the operations that |
|
513 |
// follow that also require a safepoint |
|
514 |
if (_cur_vm_operation != NULL && |
|
515 |
_cur_vm_operation->evaluate_at_safepoint()) { |
|
516 |
safepoint_ops = _vm_queue->drain_at_safepoint_priority(); |
|
517 |
} |
|
518 |
} |
|
519 |
||
520 |
if (should_terminate()) break; |
|
521 |
} // Release mu_queue_lock |
|
522 |
||
523 |
// |
|
524 |
// Execute VM operation |
|
525 |
// |
|
526 |
{ HandleMark hm(VMThread::vm_thread()); |
|
527 |
||
528 |
EventMark em("Executing VM operation: %s", vm_operation()->name()); |
|
529 |
assert(_cur_vm_operation != NULL, "we should have found an operation to execute"); |
|
530 |
||
531 |
// If we are at a safepoint we will evaluate all the operations that |
|
532 |
// follow that also require a safepoint |
|
533 |
if (_cur_vm_operation->evaluate_at_safepoint()) { |
|
46732
05423d4b10d2
8185273: Test8004741.java crashes with SIGSEGV in JDK10-hs nightly
dcubed
parents:
46589
diff
changeset
|
534 |
log_debug(vmthread)("Evaluating safepoint VM operation: %s", _cur_vm_operation->name()); |
1 | 535 |
|
536 |
_vm_queue->set_drain_list(safepoint_ops); // ensure ops can be scanned |
|
537 |
||
538 |
SafepointSynchronize::begin(); |
|
53020
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
539 |
|
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
540 |
if (_timeout_task != NULL) { |
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
541 |
_timeout_task->arm(); |
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
542 |
} |
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
543 |
|
1 | 544 |
evaluate_operation(_cur_vm_operation); |
545 |
// now process all queued safepoint ops, iteratively draining |
|
546 |
// the queue until there are none left |
|
547 |
do { |
|
548 |
_cur_vm_operation = safepoint_ops; |
|
549 |
if (_cur_vm_operation != NULL) { |
|
550 |
do { |
|
58225
4eebb9aadbe3
8231201: hs_err should print coalesced safepoint operations in Events section
shade
parents:
57758
diff
changeset
|
551 |
EventMark em("Executing coalesced safepoint VM operation: %s", _cur_vm_operation->name()); |
46732
05423d4b10d2
8185273: Test8004741.java crashes with SIGSEGV in JDK10-hs nightly
dcubed
parents:
46589
diff
changeset
|
552 |
log_debug(vmthread)("Evaluating coalesced safepoint VM operation: %s", _cur_vm_operation->name()); |
1 | 553 |
// evaluate_operation deletes the op object so we have |
554 |
// to grab the next op now |
|
555 |
VM_Operation* next = _cur_vm_operation->next(); |
|
556 |
_vm_queue->set_drain_list(next); |
|
557 |
evaluate_operation(_cur_vm_operation); |
|
558 |
_cur_vm_operation = next; |
|
53895 | 559 |
_coalesced_count++; |
1 | 560 |
} while (_cur_vm_operation != NULL); |
561 |
} |
|
562 |
// There is a chance that a thread enqueued a safepoint op |
|
563 |
// since we released the op-queue lock and initiated the safepoint. |
|
564 |
// So we drain the queue again if there is anything there, as an |
|
565 |
// optimization to try and reduce the number of safepoints. |
|
566 |
// As the safepoint synchronizes us with JavaThreads we will see |
|
567 |
// any enqueue made by a JavaThread, but the peek will not |
|
568 |
// necessarily detect a concurrent enqueue by a GC thread, but |
|
569 |
// that simply means the op will wait for the next major cycle of the |
|
570 |
// VMThread - just as it would if the GC thread lost the race for |
|
571 |
// the lock. |
|
572 |
if (_vm_queue->peek_at_safepoint_priority()) { |
|
573 |
// must hold lock while draining queue |
|
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54278
diff
changeset
|
574 |
MutexLocker mu_queue(VMOperationQueue_lock, |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54278
diff
changeset
|
575 |
Mutex::_no_safepoint_check_flag); |
1 | 576 |
safepoint_ops = _vm_queue->drain_at_safepoint_priority(); |
577 |
} else { |
|
578 |
safepoint_ops = NULL; |
|
579 |
} |
|
580 |
} while(safepoint_ops != NULL); |
|
581 |
||
582 |
_vm_queue->set_drain_list(NULL); |
|
583 |
||
53020
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
584 |
if (_timeout_task != NULL) { |
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
585 |
_timeout_task->disarm(); |
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
586 |
} |
c403f39ec349
8181143: Introduce diagnostic flag to abort VM on too long VM operations
shade
parents:
52877
diff
changeset
|
587 |
|
1 | 588 |
// Complete safepoint synchronization |
589 |
SafepointSynchronize::end(); |
|
590 |
||
591 |
} else { // not a safepoint operation |
|
46732
05423d4b10d2
8185273: Test8004741.java crashes with SIGSEGV in JDK10-hs nightly
dcubed
parents:
46589
diff
changeset
|
592 |
log_debug(vmthread)("Evaluating non-safepoint VM operation: %s", _cur_vm_operation->name()); |
1 | 593 |
if (TraceLongCompiles) { |
594 |
elapsedTimer t; |
|
595 |
t.start(); |
|
596 |
evaluate_operation(_cur_vm_operation); |
|
597 |
t.stop(); |
|
598 |
double secs = t.seconds(); |
|
599 |
if (secs * 1e3 > LongCompileThreshold) { |
|
600 |
// XXX - _cur_vm_operation should not be accessed after |
|
601 |
// the completed count has been incremented; the waiting |
|
602 |
// thread may have already freed this memory. |
|
603 |
tty->print_cr("vm %s: %3.7f secs]", _cur_vm_operation->name(), secs); |
|
604 |
} |
|
605 |
} else { |
|
606 |
evaluate_operation(_cur_vm_operation); |
|
607 |
} |
|
608 |
||
609 |
_cur_vm_operation = NULL; |
|
610 |
} |
|
611 |
} |
|
612 |
||
613 |
// |
|
54663
f03d5a093093
8074355: make MutexLocker smarter about non-JavaThreads
coleenp
parents:
54645
diff
changeset
|
614 |
// Notify (potential) waiting Java thread(s) |
58409
a595e67d6683
8184732: Deadlock detection improvements for 'special' locks
coleenp
parents:
58291
diff
changeset
|
615 |
{ MonitorLocker mu(VMOperationRequest_lock, Mutex::_no_safepoint_check_flag); |
a595e67d6683
8184732: Deadlock detection improvements for 'special' locks
coleenp
parents:
58291
diff
changeset
|
616 |
mu.notify_all(); |
1 | 617 |
} |
618 |
} |
|
619 |
} |
|
620 |
||
49594
898ef81cbc0e
8200106: Move NoSafepointVerifier out from gcLocker.hpp
stefank
parents:
49449
diff
changeset
|
621 |
// A SkipGCALot object is used to elide the usual effect of gc-a-lot |
898ef81cbc0e
8200106: Move NoSafepointVerifier out from gcLocker.hpp
stefank
parents:
49449
diff
changeset
|
622 |
// over a section of execution by a thread. Currently, it's used only to |
898ef81cbc0e
8200106: Move NoSafepointVerifier out from gcLocker.hpp
stefank
parents:
49449
diff
changeset
|
623 |
// prevent re-entrant calls to GC. |
898ef81cbc0e
8200106: Move NoSafepointVerifier out from gcLocker.hpp
stefank
parents:
49449
diff
changeset
|
624 |
class SkipGCALot : public StackObj { |
898ef81cbc0e
8200106: Move NoSafepointVerifier out from gcLocker.hpp
stefank
parents:
49449
diff
changeset
|
625 |
private: |
898ef81cbc0e
8200106: Move NoSafepointVerifier out from gcLocker.hpp
stefank
parents:
49449
diff
changeset
|
626 |
bool _saved; |
898ef81cbc0e
8200106: Move NoSafepointVerifier out from gcLocker.hpp
stefank
parents:
49449
diff
changeset
|
627 |
Thread* _t; |
898ef81cbc0e
8200106: Move NoSafepointVerifier out from gcLocker.hpp
stefank
parents:
49449
diff
changeset
|
628 |
|
898ef81cbc0e
8200106: Move NoSafepointVerifier out from gcLocker.hpp
stefank
parents:
49449
diff
changeset
|
629 |
public: |
898ef81cbc0e
8200106: Move NoSafepointVerifier out from gcLocker.hpp
stefank
parents:
49449
diff
changeset
|
630 |
#ifdef ASSERT |
898ef81cbc0e
8200106: Move NoSafepointVerifier out from gcLocker.hpp
stefank
parents:
49449
diff
changeset
|
631 |
SkipGCALot(Thread* t) : _t(t) { |
898ef81cbc0e
8200106: Move NoSafepointVerifier out from gcLocker.hpp
stefank
parents:
49449
diff
changeset
|
632 |
_saved = _t->skip_gcalot(); |
898ef81cbc0e
8200106: Move NoSafepointVerifier out from gcLocker.hpp
stefank
parents:
49449
diff
changeset
|
633 |
_t->set_skip_gcalot(true); |
898ef81cbc0e
8200106: Move NoSafepointVerifier out from gcLocker.hpp
stefank
parents:
49449
diff
changeset
|
634 |
} |
898ef81cbc0e
8200106: Move NoSafepointVerifier out from gcLocker.hpp
stefank
parents:
49449
diff
changeset
|
635 |
|
898ef81cbc0e
8200106: Move NoSafepointVerifier out from gcLocker.hpp
stefank
parents:
49449
diff
changeset
|
636 |
~SkipGCALot() { |
898ef81cbc0e
8200106: Move NoSafepointVerifier out from gcLocker.hpp
stefank
parents:
49449
diff
changeset
|
637 |
assert(_t->skip_gcalot(), "Save-restore protocol invariant"); |
898ef81cbc0e
8200106: Move NoSafepointVerifier out from gcLocker.hpp
stefank
parents:
49449
diff
changeset
|
638 |
_t->set_skip_gcalot(_saved); |
898ef81cbc0e
8200106: Move NoSafepointVerifier out from gcLocker.hpp
stefank
parents:
49449
diff
changeset
|
639 |
} |
898ef81cbc0e
8200106: Move NoSafepointVerifier out from gcLocker.hpp
stefank
parents:
49449
diff
changeset
|
640 |
#else |
898ef81cbc0e
8200106: Move NoSafepointVerifier out from gcLocker.hpp
stefank
parents:
49449
diff
changeset
|
641 |
SkipGCALot(Thread* t) { } |
898ef81cbc0e
8200106: Move NoSafepointVerifier out from gcLocker.hpp
stefank
parents:
49449
diff
changeset
|
642 |
~SkipGCALot() { } |
898ef81cbc0e
8200106: Move NoSafepointVerifier out from gcLocker.hpp
stefank
parents:
49449
diff
changeset
|
643 |
#endif |
898ef81cbc0e
8200106: Move NoSafepointVerifier out from gcLocker.hpp
stefank
parents:
49449
diff
changeset
|
644 |
}; |
898ef81cbc0e
8200106: Move NoSafepointVerifier out from gcLocker.hpp
stefank
parents:
49449
diff
changeset
|
645 |
|
1 | 646 |
void VMThread::execute(VM_Operation* op) { |
647 |
Thread* t = Thread::current(); |
|
648 |
||
649 |
if (!t->is_VM_thread()) { |
|
2995
d8283445992a
6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents:
1
diff
changeset
|
650 |
SkipGCALot sgcalot(t); // avoid re-entrant attempts to gc-a-lot |
1 | 651 |
// JavaThread or WatcherThread |
59325 | 652 |
t->check_for_valid_safepoint_state(); |
1 | 653 |
|
654 |
// New request from Java thread, evaluate prologue |
|
655 |
if (!op->doit_prologue()) { |
|
656 |
return; // op was cancelled |
|
657 |
} |
|
658 |
||
659 |
// Setup VM_operations for execution |
|
57758 | 660 |
op->set_calling_thread(t); |
1 | 661 |
|
59325 | 662 |
// Get ticket number for the VM operation |
663 |
int ticket = t->vm_operation_ticket(); |
|
1 | 664 |
|
665 |
// Add VM operation to list of waiting threads. We are guaranteed not to block while holding the |
|
666 |
// VMOperationQueue_lock, so we can block without a safepoint check. This allows vm operation requests |
|
667 |
// to be queued up during a safepoint synchronization. |
|
668 |
{ |
|
58409
a595e67d6683
8184732: Deadlock detection improvements for 'special' locks
coleenp
parents:
58291
diff
changeset
|
669 |
MonitorLocker ml(VMOperationQueue_lock, Mutex::_no_safepoint_check_flag); |
46732
05423d4b10d2
8185273: Test8004741.java crashes with SIGSEGV in JDK10-hs nightly
dcubed
parents:
46589
diff
changeset
|
670 |
log_debug(vmthread)("Adding VM operation: %s", op->name()); |
55128
35192d9c2b76
8225016: Dead code due to VMOperationQueue::add() always returning true
pchilanomate
parents:
54786
diff
changeset
|
671 |
_vm_queue->add(op); |
46732
05423d4b10d2
8185273: Test8004741.java crashes with SIGSEGV in JDK10-hs nightly
dcubed
parents:
46589
diff
changeset
|
672 |
op->set_timestamp(os::javaTimeMillis()); |
58409
a595e67d6683
8184732: Deadlock detection improvements for 'special' locks
coleenp
parents:
58291
diff
changeset
|
673 |
ml.notify(); |
1 | 674 |
} |
59325 | 675 |
{ |
676 |
// Wait for completion of request |
|
1 | 677 |
// Note: only a JavaThread triggers the safepoint check when locking |
54645
05aaccf7d558
8222988: Use MonitorLocker rather than MutexLocker when wait/notify used
coleenp
parents:
54623
diff
changeset
|
678 |
MonitorLocker ml(VMOperationRequest_lock, |
05aaccf7d558
8222988: Use MonitorLocker rather than MutexLocker when wait/notify used
coleenp
parents:
54623
diff
changeset
|
679 |
t->is_Java_thread() ? Mutex::_safepoint_check_flag : Mutex::_no_safepoint_check_flag); |
1 | 680 |
while(t->vm_operation_completed_count() < ticket) { |
54645
05aaccf7d558
8222988: Use MonitorLocker rather than MutexLocker when wait/notify used
coleenp
parents:
54623
diff
changeset
|
681 |
ml.wait(); |
1 | 682 |
} |
683 |
} |
|
59325 | 684 |
op->doit_epilogue(); |
1 | 685 |
} else { |
686 |
// invoked by VM thread; usually nested VM operation |
|
687 |
assert(t->is_VM_thread(), "must be a VM thread"); |
|
688 |
VM_Operation* prev_vm_operation = vm_operation(); |
|
689 |
if (prev_vm_operation != NULL) { |
|
690 |
// Check the VM operation allows nested VM operation. This normally not the case, e.g., the compiler |
|
691 |
// does not allow nested scavenges or compiles. |
|
692 |
if (!prev_vm_operation->allow_nested_vm_operations()) { |
|
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
30764
diff
changeset
|
693 |
fatal("Nested VM operation %s requested by operation %s", |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
30764
diff
changeset
|
694 |
op->name(), vm_operation()->name()); |
1 | 695 |
} |
57758 | 696 |
op->set_calling_thread(prev_vm_operation->calling_thread()); |
1 | 697 |
} |
698 |
||
699 |
EventMark em("Executing %s VM operation: %s", prev_vm_operation ? "nested" : "", op->name()); |
|
700 |
||
701 |
// Release all internal handles after operation is evaluated |
|
702 |
HandleMark hm(t); |
|
703 |
_cur_vm_operation = op; |
|
704 |
||
705 |
if (op->evaluate_at_safepoint() && !SafepointSynchronize::is_at_safepoint()) { |
|
706 |
SafepointSynchronize::begin(); |
|
707 |
op->evaluate(); |
|
708 |
SafepointSynchronize::end(); |
|
709 |
} else { |
|
710 |
op->evaluate(); |
|
711 |
} |
|
712 |
||
713 |
_cur_vm_operation = prev_vm_operation; |
|
714 |
} |
|
715 |
} |
|
716 |
||
717 |
||
38074
8475fdc6dcc3
8154580: Save mirror in interpreter frame to enable cleanups of CLDClosure
coleenp
parents:
37176
diff
changeset
|
718 |
void VMThread::oops_do(OopClosure* f, CodeBlobClosure* cf) { |
8475fdc6dcc3
8154580: Save mirror in interpreter frame to enable cleanups of CLDClosure
coleenp
parents:
37176
diff
changeset
|
719 |
Thread::oops_do(f, cf); |
1 | 720 |
_vm_queue->oops_do(f); |
721 |
} |
|
722 |
||
723 |
//------------------------------------------------------------------------------------------------------------------ |
|
724 |
#ifndef PRODUCT |
|
725 |
||
726 |
void VMOperationQueue::verify_queue(int prio) { |
|
727 |
// Check that list is correctly linked |
|
728 |
int length = _queue_length[prio]; |
|
729 |
VM_Operation *cur = _queue[prio]; |
|
730 |
int i; |
|
731 |
||
732 |
// Check forward links |
|
733 |
for(i = 0; i < length; i++) { |
|
734 |
cur = cur->next(); |
|
735 |
assert(cur != _queue[prio], "list to short (forward)"); |
|
736 |
} |
|
737 |
assert(cur->next() == _queue[prio], "list to long (forward)"); |
|
738 |
||
739 |
// Check backwards links |
|
740 |
cur = _queue[prio]; |
|
741 |
for(i = 0; i < length; i++) { |
|
742 |
cur = cur->prev(); |
|
743 |
assert(cur != _queue[prio], "list to short (backwards)"); |
|
744 |
} |
|
745 |
assert(cur->prev() == _queue[prio], "list to long (backwards)"); |
|
746 |
} |
|
747 |
||
748 |
#endif |
|
749 |
||
750 |
void VMThread::verify() { |
|
38074
8475fdc6dcc3
8154580: Save mirror in interpreter frame to enable cleanups of CLDClosure
coleenp
parents:
37176
diff
changeset
|
751 |
oops_do(&VerifyOopClosure::verify_oop, NULL); |
1 | 752 |
} |