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