Mercurial > hg > truffle
annotate src/share/vm/runtime/thread.cpp @ 1721:413ad0331a0c
6977924: Changes for 6975078 produce build error with certain gcc versions
Summary: The changes introduced for 6975078 assign badHeapOopVal to the _allocation field in the ResourceObj class. In 32 bit linux builds with certain versions of gcc this assignment will be flagged as an error while compiling allocation.cpp. In 32 bit builds the constant value badHeapOopVal (which is cast to an intptr_t) is negative. The _allocation field is typed as an unsigned intptr_t and gcc catches this as an error.
Reviewed-by: jcoomes, ysr, phh
author | johnc |
---|---|
date | Wed, 18 Aug 2010 10:59:06 -0700 |
parents | 21e519b91576 |
children | ee5cc9e78493 |
rev | line source |
---|---|
0 | 1 /* |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1320
diff
changeset
|
2 * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. |
0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 * | |
5 * This code is free software; you can redistribute it and/or modify it | |
6 * under the terms of the GNU General Public License version 2 only, as | |
7 * published by the Free Software Foundation. | |
8 * | |
9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
12 * version 2 for more details (a copy is included in the LICENSE file that | |
13 * accompanied this code). | |
14 * | |
15 * You should have received a copy of the GNU General Public License version | |
16 * 2 along with this work; if not, write to the Free Software Foundation, | |
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
18 * | |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1320
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1320
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1320
diff
changeset
|
21 * questions. |
0 | 22 * |
23 */ | |
24 | |
25 # include "incls/_precompiled.incl" | |
26 # include "incls/_thread.cpp.incl" | |
27 | |
28 #ifdef DTRACE_ENABLED | |
29 | |
30 // Only bother with this argument setup if dtrace is available | |
31 | |
32 HS_DTRACE_PROBE_DECL(hotspot, vm__init__begin); | |
33 HS_DTRACE_PROBE_DECL(hotspot, vm__init__end); | |
34 HS_DTRACE_PROBE_DECL5(hotspot, thread__start, char*, intptr_t, | |
35 intptr_t, intptr_t, bool); | |
36 HS_DTRACE_PROBE_DECL5(hotspot, thread__stop, char*, intptr_t, | |
37 intptr_t, intptr_t, bool); | |
38 | |
39 #define DTRACE_THREAD_PROBE(probe, javathread) \ | |
40 { \ | |
41 ResourceMark rm(this); \ | |
42 int len = 0; \ | |
43 const char* name = (javathread)->get_thread_name(); \ | |
44 len = strlen(name); \ | |
45 HS_DTRACE_PROBE5(hotspot, thread__##probe, \ | |
46 name, len, \ | |
47 java_lang_Thread::thread_id((javathread)->threadObj()), \ | |
48 (javathread)->osthread()->thread_id(), \ | |
49 java_lang_Thread::is_daemon((javathread)->threadObj())); \ | |
50 } | |
51 | |
52 #else // ndef DTRACE_ENABLED | |
53 | |
54 #define DTRACE_THREAD_PROBE(probe, javathread) | |
55 | |
56 #endif // ndef DTRACE_ENABLED | |
57 | |
58 // Class hierarchy | |
59 // - Thread | |
60 // - VMThread | |
61 // - WatcherThread | |
62 // - ConcurrentMarkSweepThread | |
63 // - JavaThread | |
64 // - CompilerThread | |
65 | |
66 // ======= Thread ======== | |
67 | |
68 // Support for forcing alignment of thread objects for biased locking | |
69 void* Thread::operator new(size_t size) { | |
70 if (UseBiasedLocking) { | |
71 const int alignment = markOopDesc::biased_lock_alignment; | |
72 size_t aligned_size = size + (alignment - sizeof(intptr_t)); | |
73 void* real_malloc_addr = CHeapObj::operator new(aligned_size); | |
74 void* aligned_addr = (void*) align_size_up((intptr_t) real_malloc_addr, alignment); | |
75 assert(((uintptr_t) aligned_addr + (uintptr_t) size) <= | |
76 ((uintptr_t) real_malloc_addr + (uintptr_t) aligned_size), | |
77 "JavaThread alignment code overflowed allocated storage"); | |
78 if (TraceBiasedLocking) { | |
79 if (aligned_addr != real_malloc_addr) | |
80 tty->print_cr("Aligned thread " INTPTR_FORMAT " to " INTPTR_FORMAT, | |
81 real_malloc_addr, aligned_addr); | |
82 } | |
83 ((Thread*) aligned_addr)->_real_malloc_address = real_malloc_addr; | |
84 return aligned_addr; | |
85 } else { | |
86 return CHeapObj::operator new(size); | |
87 } | |
88 } | |
89 | |
90 void Thread::operator delete(void* p) { | |
91 if (UseBiasedLocking) { | |
92 void* real_malloc_addr = ((Thread*) p)->_real_malloc_address; | |
93 CHeapObj::operator delete(real_malloc_addr); | |
94 } else { | |
95 CHeapObj::operator delete(p); | |
96 } | |
97 } | |
98 | |
99 | |
100 // Base class for all threads: VMThread, WatcherThread, ConcurrentMarkSweepThread, | |
101 // JavaThread | |
102 | |
103 | |
104 Thread::Thread() { | |
105 // stack | |
106 _stack_base = NULL; | |
107 _stack_size = 0; | |
108 _self_raw_id = 0; | |
109 _lgrp_id = -1; | |
110 _osthread = NULL; | |
111 | |
112 // allocated data structures | |
113 set_resource_area(new ResourceArea()); | |
114 set_handle_area(new HandleArea(NULL)); | |
115 set_active_handles(NULL); | |
116 set_free_handle_block(NULL); | |
117 set_last_handle_mark(NULL); | |
118 set_osthread(NULL); | |
119 | |
120 // This initial value ==> never claimed. | |
121 _oops_do_parity = 0; | |
122 | |
123 // the handle mark links itself to last_handle_mark | |
124 new HandleMark(this); | |
125 | |
126 // plain initialization | |
127 debug_only(_owned_locks = NULL;) | |
128 debug_only(_allow_allocation_count = 0;) | |
129 NOT_PRODUCT(_allow_safepoint_count = 0;) | |
806
821269eca479
6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents:
702
diff
changeset
|
130 NOT_PRODUCT(_skip_gcalot = false;) |
0 | 131 CHECK_UNHANDLED_OOPS_ONLY(_gc_locked_out_count = 0;) |
132 _jvmti_env_iteration_count = 0; | |
133 _vm_operation_started_count = 0; | |
134 _vm_operation_completed_count = 0; | |
135 _current_pending_monitor = NULL; | |
136 _current_pending_monitor_is_from_java = true; | |
137 _current_waiting_monitor = NULL; | |
138 _num_nested_signal = 0; | |
139 omFreeList = NULL ; | |
140 omFreeCount = 0 ; | |
141 omFreeProvision = 32 ; | |
1587 | 142 omInUseList = NULL ; |
143 omInUseCount = 0 ; | |
0 | 144 |
145 _SR_lock = new Monitor(Mutex::suspend_resume, "SR_lock", true); | |
146 _suspend_flags = 0; | |
147 | |
148 // thread-specific hashCode stream generator state - Marsaglia shift-xor form | |
149 _hashStateX = os::random() ; | |
150 _hashStateY = 842502087 ; | |
151 _hashStateZ = 0x8767 ; // (int)(3579807591LL & 0xffff) ; | |
152 _hashStateW = 273326509 ; | |
153 | |
154 _OnTrap = 0 ; | |
155 _schedctl = NULL ; | |
156 _Stalled = 0 ; | |
157 _TypeTag = 0x2BAD ; | |
158 | |
159 // Many of the following fields are effectively final - immutable | |
160 // Note that nascent threads can't use the Native Monitor-Mutex | |
161 // construct until the _MutexEvent is initialized ... | |
162 // CONSIDER: instead of using a fixed set of purpose-dedicated ParkEvents | |
163 // we might instead use a stack of ParkEvents that we could provision on-demand. | |
164 // The stack would act as a cache to avoid calls to ParkEvent::Allocate() | |
165 // and ::Release() | |
166 _ParkEvent = ParkEvent::Allocate (this) ; | |
167 _SleepEvent = ParkEvent::Allocate (this) ; | |
168 _MutexEvent = ParkEvent::Allocate (this) ; | |
169 _MuxEvent = ParkEvent::Allocate (this) ; | |
170 | |
171 #ifdef CHECK_UNHANDLED_OOPS | |
172 if (CheckUnhandledOops) { | |
173 _unhandled_oops = new UnhandledOops(this); | |
174 } | |
175 #endif // CHECK_UNHANDLED_OOPS | |
176 #ifdef ASSERT | |
177 if (UseBiasedLocking) { | |
178 assert((((uintptr_t) this) & (markOopDesc::biased_lock_alignment - 1)) == 0, "forced alignment of thread object failed"); | |
179 assert(this == _real_malloc_address || | |
180 this == (void*) align_size_up((intptr_t) _real_malloc_address, markOopDesc::biased_lock_alignment), | |
181 "bug in forced alignment of thread objects"); | |
182 } | |
183 #endif /* ASSERT */ | |
184 } | |
185 | |
186 void Thread::initialize_thread_local_storage() { | |
187 // Note: Make sure this method only calls | |
188 // non-blocking operations. Otherwise, it might not work | |
189 // with the thread-startup/safepoint interaction. | |
190 | |
191 // During Java thread startup, safepoint code should allow this | |
192 // method to complete because it may need to allocate memory to | |
193 // store information for the new thread. | |
194 | |
195 // initialize structure dependent on thread local storage | |
196 ThreadLocalStorage::set_thread(this); | |
197 | |
198 // set up any platform-specific state. | |
199 os::initialize_thread(); | |
200 | |
201 } | |
202 | |
203 void Thread::record_stack_base_and_size() { | |
204 set_stack_base(os::current_stack_base()); | |
205 set_stack_size(os::current_stack_size()); | |
206 } | |
207 | |
208 | |
209 Thread::~Thread() { | |
210 // Reclaim the objectmonitors from the omFreeList of the moribund thread. | |
211 ObjectSynchronizer::omFlush (this) ; | |
212 | |
213 // deallocate data structures | |
214 delete resource_area(); | |
215 // since the handle marks are using the handle area, we have to deallocated the root | |
216 // handle mark before deallocating the thread's handle area, | |
217 assert(last_handle_mark() != NULL, "check we have an element"); | |
218 delete last_handle_mark(); | |
219 assert(last_handle_mark() == NULL, "check we have reached the end"); | |
220 | |
221 // It's possible we can encounter a null _ParkEvent, etc., in stillborn threads. | |
222 // We NULL out the fields for good hygiene. | |
223 ParkEvent::Release (_ParkEvent) ; _ParkEvent = NULL ; | |
224 ParkEvent::Release (_SleepEvent) ; _SleepEvent = NULL ; | |
225 ParkEvent::Release (_MutexEvent) ; _MutexEvent = NULL ; | |
226 ParkEvent::Release (_MuxEvent) ; _MuxEvent = NULL ; | |
227 | |
228 delete handle_area(); | |
229 | |
230 // osthread() can be NULL, if creation of thread failed. | |
231 if (osthread() != NULL) os::free_thread(osthread()); | |
232 | |
233 delete _SR_lock; | |
234 | |
235 // clear thread local storage if the Thread is deleting itself | |
236 if (this == Thread::current()) { | |
237 ThreadLocalStorage::set_thread(NULL); | |
238 } else { | |
239 // In the case where we're not the current thread, invalidate all the | |
240 // caches in case some code tries to get the current thread or the | |
241 // thread that was destroyed, and gets stale information. | |
242 ThreadLocalStorage::invalidate_all(); | |
243 } | |
244 CHECK_UNHANDLED_OOPS_ONLY(if (CheckUnhandledOops) delete unhandled_oops();) | |
245 } | |
246 | |
247 // NOTE: dummy function for assertion purpose. | |
248 void Thread::run() { | |
249 ShouldNotReachHere(); | |
250 } | |
251 | |
252 #ifdef ASSERT | |
253 // Private method to check for dangling thread pointer | |
254 void check_for_dangling_thread_pointer(Thread *thread) { | |
255 assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(), | |
256 "possibility of dangling Thread pointer"); | |
257 } | |
258 #endif | |
259 | |
260 | |
261 #ifndef PRODUCT | |
262 // Tracing method for basic thread operations | |
263 void Thread::trace(const char* msg, const Thread* const thread) { | |
264 if (!TraceThreadEvents) return; | |
265 ResourceMark rm; | |
266 ThreadCritical tc; | |
267 const char *name = "non-Java thread"; | |
268 int prio = -1; | |
269 if (thread->is_Java_thread() | |
270 && !thread->is_Compiler_thread()) { | |
271 // The Threads_lock must be held to get information about | |
272 // this thread but may not be in some situations when | |
273 // tracing thread events. | |
274 bool release_Threads_lock = false; | |
275 if (!Threads_lock->owned_by_self()) { | |
276 Threads_lock->lock(); | |
277 release_Threads_lock = true; | |
278 } | |
279 JavaThread* jt = (JavaThread *)thread; | |
280 name = (char *)jt->get_thread_name(); | |
281 oop thread_oop = jt->threadObj(); | |
282 if (thread_oop != NULL) { | |
283 prio = java_lang_Thread::priority(thread_oop); | |
284 } | |
285 if (release_Threads_lock) { | |
286 Threads_lock->unlock(); | |
287 } | |
288 } | |
289 tty->print_cr("Thread::%s " INTPTR_FORMAT " [%lx] %s (prio: %d)", msg, thread, thread->osthread()->thread_id(), name, prio); | |
290 } | |
291 #endif | |
292 | |
293 | |
294 ThreadPriority Thread::get_priority(const Thread* const thread) { | |
295 trace("get priority", thread); | |
296 ThreadPriority priority; | |
297 // Can return an error! | |
298 (void)os::get_priority(thread, priority); | |
299 assert(MinPriority <= priority && priority <= MaxPriority, "non-Java priority found"); | |
300 return priority; | |
301 } | |
302 | |
303 void Thread::set_priority(Thread* thread, ThreadPriority priority) { | |
304 trace("set priority", thread); | |
305 debug_only(check_for_dangling_thread_pointer(thread);) | |
306 // Can return an error! | |
307 (void)os::set_priority(thread, priority); | |
308 } | |
309 | |
310 | |
311 void Thread::start(Thread* thread) { | |
312 trace("start", thread); | |
313 // Start is different from resume in that its safety is guaranteed by context or | |
314 // being called from a Java method synchronized on the Thread object. | |
315 if (!DisableStartThread) { | |
316 if (thread->is_Java_thread()) { | |
317 // Initialize the thread state to RUNNABLE before starting this thread. | |
318 // Can not set it after the thread started because we do not know the | |
319 // exact thread state at that time. It could be in MONITOR_WAIT or | |
320 // in SLEEPING or some other state. | |
321 java_lang_Thread::set_thread_status(((JavaThread*)thread)->threadObj(), | |
322 java_lang_Thread::RUNNABLE); | |
323 } | |
324 os::start_thread(thread); | |
325 } | |
326 } | |
327 | |
328 // Enqueue a VM_Operation to do the job for us - sometime later | |
329 void Thread::send_async_exception(oop java_thread, oop java_throwable) { | |
330 VM_ThreadStop* vm_stop = new VM_ThreadStop(java_thread, java_throwable); | |
331 VMThread::execute(vm_stop); | |
332 } | |
333 | |
334 | |
335 // | |
336 // Check if an external suspend request has completed (or has been | |
337 // cancelled). Returns true if the thread is externally suspended and | |
338 // false otherwise. | |
339 // | |
340 // The bits parameter returns information about the code path through | |
341 // the routine. Useful for debugging: | |
342 // | |
343 // set in is_ext_suspend_completed(): | |
344 // 0x00000001 - routine was entered | |
345 // 0x00000010 - routine return false at end | |
346 // 0x00000100 - thread exited (return false) | |
347 // 0x00000200 - suspend request cancelled (return false) | |
348 // 0x00000400 - thread suspended (return true) | |
349 // 0x00001000 - thread is in a suspend equivalent state (return true) | |
350 // 0x00002000 - thread is native and walkable (return true) | |
351 // 0x00004000 - thread is native_trans and walkable (needed retry) | |
352 // | |
353 // set in wait_for_ext_suspend_completion(): | |
354 // 0x00010000 - routine was entered | |
355 // 0x00020000 - suspend request cancelled before loop (return false) | |
356 // 0x00040000 - thread suspended before loop (return true) | |
357 // 0x00080000 - suspend request cancelled in loop (return false) | |
358 // 0x00100000 - thread suspended in loop (return true) | |
359 // 0x00200000 - suspend not completed during retry loop (return false) | |
360 // | |
361 | |
362 // Helper class for tracing suspend wait debug bits. | |
363 // | |
364 // 0x00000100 indicates that the target thread exited before it could | |
365 // self-suspend which is not a wait failure. 0x00000200, 0x00020000 and | |
366 // 0x00080000 each indicate a cancelled suspend request so they don't | |
367 // count as wait failures either. | |
368 #define DEBUG_FALSE_BITS (0x00000010 | 0x00200000) | |
369 | |
370 class TraceSuspendDebugBits : public StackObj { | |
371 private: | |
372 JavaThread * jt; | |
373 bool is_wait; | |
374 bool called_by_wait; // meaningful when !is_wait | |
375 uint32_t * bits; | |
376 | |
377 public: | |
378 TraceSuspendDebugBits(JavaThread *_jt, bool _is_wait, bool _called_by_wait, | |
379 uint32_t *_bits) { | |
380 jt = _jt; | |
381 is_wait = _is_wait; | |
382 called_by_wait = _called_by_wait; | |
383 bits = _bits; | |
384 } | |
385 | |
386 ~TraceSuspendDebugBits() { | |
387 if (!is_wait) { | |
388 #if 1 | |
389 // By default, don't trace bits for is_ext_suspend_completed() calls. | |
390 // That trace is very chatty. | |
391 return; | |
392 #else | |
393 if (!called_by_wait) { | |
394 // If tracing for is_ext_suspend_completed() is enabled, then only | |
395 // trace calls to it from wait_for_ext_suspend_completion() | |
396 return; | |
397 } | |
398 #endif | |
399 } | |
400 | |
401 if (AssertOnSuspendWaitFailure || TraceSuspendWaitFailures) { | |
402 if (bits != NULL && (*bits & DEBUG_FALSE_BITS) != 0) { | |
403 MutexLocker ml(Threads_lock); // needed for get_thread_name() | |
404 ResourceMark rm; | |
405 | |
406 tty->print_cr( | |
407 "Failed wait_for_ext_suspend_completion(thread=%s, debug_bits=%x)", | |
408 jt->get_thread_name(), *bits); | |
409 | |
410 guarantee(!AssertOnSuspendWaitFailure, "external suspend wait failed"); | |
411 } | |
412 } | |
413 } | |
414 }; | |
415 #undef DEBUG_FALSE_BITS | |
416 | |
417 | |
418 bool JavaThread::is_ext_suspend_completed(bool called_by_wait, int delay, uint32_t *bits) { | |
419 TraceSuspendDebugBits tsdb(this, false /* !is_wait */, called_by_wait, bits); | |
420 | |
421 bool did_trans_retry = false; // only do thread_in_native_trans retry once | |
422 bool do_trans_retry; // flag to force the retry | |
423 | |
424 *bits |= 0x00000001; | |
425 | |
426 do { | |
427 do_trans_retry = false; | |
428 | |
429 if (is_exiting()) { | |
430 // Thread is in the process of exiting. This is always checked | |
431 // first to reduce the risk of dereferencing a freed JavaThread. | |
432 *bits |= 0x00000100; | |
433 return false; | |
434 } | |
435 | |
436 if (!is_external_suspend()) { | |
437 // Suspend request is cancelled. This is always checked before | |
438 // is_ext_suspended() to reduce the risk of a rogue resume | |
439 // confusing the thread that made the suspend request. | |
440 *bits |= 0x00000200; | |
441 return false; | |
442 } | |
443 | |
444 if (is_ext_suspended()) { | |
445 // thread is suspended | |
446 *bits |= 0x00000400; | |
447 return true; | |
448 } | |
449 | |
450 // Now that we no longer do hard suspends of threads running | |
451 // native code, the target thread can be changing thread state | |
452 // while we are in this routine: | |
453 // | |
454 // _thread_in_native -> _thread_in_native_trans -> _thread_blocked | |
455 // | |
456 // We save a copy of the thread state as observed at this moment | |
457 // and make our decision about suspend completeness based on the | |
458 // copy. This closes the race where the thread state is seen as | |
459 // _thread_in_native_trans in the if-thread_blocked check, but is | |
460 // seen as _thread_blocked in if-thread_in_native_trans check. | |
461 JavaThreadState save_state = thread_state(); | |
462 | |
463 if (save_state == _thread_blocked && is_suspend_equivalent()) { | |
464 // If the thread's state is _thread_blocked and this blocking | |
465 // condition is known to be equivalent to a suspend, then we can | |
466 // consider the thread to be externally suspended. This means that | |
467 // the code that sets _thread_blocked has been modified to do | |
468 // self-suspension if the blocking condition releases. We also | |
469 // used to check for CONDVAR_WAIT here, but that is now covered by | |
470 // the _thread_blocked with self-suspension check. | |
471 // | |
472 // Return true since we wouldn't be here unless there was still an | |
473 // external suspend request. | |
474 *bits |= 0x00001000; | |
475 return true; | |
476 } else if (save_state == _thread_in_native && frame_anchor()->walkable()) { | |
477 // Threads running native code will self-suspend on native==>VM/Java | |
478 // transitions. If its stack is walkable (should always be the case | |
479 // unless this function is called before the actual java_suspend() | |
480 // call), then the wait is done. | |
481 *bits |= 0x00002000; | |
482 return true; | |
483 } else if (!called_by_wait && !did_trans_retry && | |
484 save_state == _thread_in_native_trans && | |
485 frame_anchor()->walkable()) { | |
486 // The thread is transitioning from thread_in_native to another | |
487 // thread state. check_safepoint_and_suspend_for_native_trans() | |
488 // will force the thread to self-suspend. If it hasn't gotten | |
489 // there yet we may have caught the thread in-between the native | |
490 // code check above and the self-suspend. Lucky us. If we were | |
491 // called by wait_for_ext_suspend_completion(), then it | |
492 // will be doing the retries so we don't have to. | |
493 // | |
494 // Since we use the saved thread state in the if-statement above, | |
495 // there is a chance that the thread has already transitioned to | |
496 // _thread_blocked by the time we get here. In that case, we will | |
497 // make a single unnecessary pass through the logic below. This | |
498 // doesn't hurt anything since we still do the trans retry. | |
499 | |
500 *bits |= 0x00004000; | |
501 | |
502 // Once the thread leaves thread_in_native_trans for another | |
503 // thread state, we break out of this retry loop. We shouldn't | |
504 // need this flag to prevent us from getting back here, but | |
505 // sometimes paranoia is good. | |
506 did_trans_retry = true; | |
507 | |
508 // We wait for the thread to transition to a more usable state. | |
509 for (int i = 1; i <= SuspendRetryCount; i++) { | |
510 // We used to do an "os::yield_all(i)" call here with the intention | |
511 // that yielding would increase on each retry. However, the parameter | |
512 // is ignored on Linux which means the yield didn't scale up. Waiting | |
513 // on the SR_lock below provides a much more predictable scale up for | |
514 // the delay. It also provides a simple/direct point to check for any | |
515 // safepoint requests from the VMThread | |
516 | |
517 // temporarily drops SR_lock while doing wait with safepoint check | |
518 // (if we're a JavaThread - the WatcherThread can also call this) | |
519 // and increase delay with each retry | |
520 SR_lock()->wait(!Thread::current()->is_Java_thread(), i * delay); | |
521 | |
522 // check the actual thread state instead of what we saved above | |
523 if (thread_state() != _thread_in_native_trans) { | |
524 // the thread has transitioned to another thread state so | |
525 // try all the checks (except this one) one more time. | |
526 do_trans_retry = true; | |
527 break; | |
528 } | |
529 } // end retry loop | |
530 | |
531 | |
532 } | |
533 } while (do_trans_retry); | |
534 | |
535 *bits |= 0x00000010; | |
536 return false; | |
537 } | |
538 | |
539 // | |
540 // Wait for an external suspend request to complete (or be cancelled). | |
541 // Returns true if the thread is externally suspended and false otherwise. | |
542 // | |
543 bool JavaThread::wait_for_ext_suspend_completion(int retries, int delay, | |
544 uint32_t *bits) { | |
545 TraceSuspendDebugBits tsdb(this, true /* is_wait */, | |
546 false /* !called_by_wait */, bits); | |
547 | |
548 // local flag copies to minimize SR_lock hold time | |
549 bool is_suspended; | |
550 bool pending; | |
551 uint32_t reset_bits; | |
552 | |
553 // set a marker so is_ext_suspend_completed() knows we are the caller | |
554 *bits |= 0x00010000; | |
555 | |
556 // We use reset_bits to reinitialize the bits value at the top of | |
557 // each retry loop. This allows the caller to make use of any | |
558 // unused bits for their own marking purposes. | |
559 reset_bits = *bits; | |
560 | |
561 { | |
562 MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag); | |
563 is_suspended = is_ext_suspend_completed(true /* called_by_wait */, | |
564 delay, bits); | |
565 pending = is_external_suspend(); | |
566 } | |
567 // must release SR_lock to allow suspension to complete | |
568 | |
569 if (!pending) { | |
570 // A cancelled suspend request is the only false return from | |
571 // is_ext_suspend_completed() that keeps us from entering the | |
572 // retry loop. | |
573 *bits |= 0x00020000; | |
574 return false; | |
575 } | |
576 | |
577 if (is_suspended) { | |
578 *bits |= 0x00040000; | |
579 return true; | |
580 } | |
581 | |
582 for (int i = 1; i <= retries; i++) { | |
583 *bits = reset_bits; // reinit to only track last retry | |
584 | |
585 // We used to do an "os::yield_all(i)" call here with the intention | |
586 // that yielding would increase on each retry. However, the parameter | |
587 // is ignored on Linux which means the yield didn't scale up. Waiting | |
588 // on the SR_lock below provides a much more predictable scale up for | |
589 // the delay. It also provides a simple/direct point to check for any | |
590 // safepoint requests from the VMThread | |
591 | |
592 { | |
593 MutexLocker ml(SR_lock()); | |
594 // wait with safepoint check (if we're a JavaThread - the WatcherThread | |
595 // can also call this) and increase delay with each retry | |
596 SR_lock()->wait(!Thread::current()->is_Java_thread(), i * delay); | |
597 | |
598 is_suspended = is_ext_suspend_completed(true /* called_by_wait */, | |
599 delay, bits); | |
600 | |
601 // It is possible for the external suspend request to be cancelled | |
602 // (by a resume) before the actual suspend operation is completed. | |
603 // Refresh our local copy to see if we still need to wait. | |
604 pending = is_external_suspend(); | |
605 } | |
606 | |
607 if (!pending) { | |
608 // A cancelled suspend request is the only false return from | |
609 // is_ext_suspend_completed() that keeps us from staying in the | |
610 // retry loop. | |
611 *bits |= 0x00080000; | |
612 return false; | |
613 } | |
614 | |
615 if (is_suspended) { | |
616 *bits |= 0x00100000; | |
617 return true; | |
618 } | |
619 } // end retry loop | |
620 | |
621 // thread did not suspend after all our retries | |
622 *bits |= 0x00200000; | |
623 return false; | |
624 } | |
625 | |
626 #ifndef PRODUCT | |
627 void JavaThread::record_jump(address target, address instr, const char* file, int line) { | |
628 | |
629 // This should not need to be atomic as the only way for simultaneous | |
630 // updates is via interrupts. Even then this should be rare or non-existant | |
631 // and we don't care that much anyway. | |
632 | |
633 int index = _jmp_ring_index; | |
634 _jmp_ring_index = (index + 1 ) & (jump_ring_buffer_size - 1); | |
635 _jmp_ring[index]._target = (intptr_t) target; | |
636 _jmp_ring[index]._instruction = (intptr_t) instr; | |
637 _jmp_ring[index]._file = file; | |
638 _jmp_ring[index]._line = line; | |
639 } | |
640 #endif /* PRODUCT */ | |
641 | |
642 // Called by flat profiler | |
643 // Callers have already called wait_for_ext_suspend_completion | |
644 // The assertion for that is currently too complex to put here: | |
645 bool JavaThread::profile_last_Java_frame(frame* _fr) { | |
646 bool gotframe = false; | |
647 // self suspension saves needed state. | |
648 if (has_last_Java_frame() && _anchor.walkable()) { | |
649 *_fr = pd_last_frame(); | |
650 gotframe = true; | |
651 } | |
652 return gotframe; | |
653 } | |
654 | |
655 void Thread::interrupt(Thread* thread) { | |
656 trace("interrupt", thread); | |
657 debug_only(check_for_dangling_thread_pointer(thread);) | |
658 os::interrupt(thread); | |
659 } | |
660 | |
661 bool Thread::is_interrupted(Thread* thread, bool clear_interrupted) { | |
662 trace("is_interrupted", thread); | |
663 debug_only(check_for_dangling_thread_pointer(thread);) | |
664 // Note: If clear_interrupted==false, this simply fetches and | |
665 // returns the value of the field osthread()->interrupted(). | |
666 return os::is_interrupted(thread, clear_interrupted); | |
667 } | |
668 | |
669 | |
670 // GC Support | |
671 bool Thread::claim_oops_do_par_case(int strong_roots_parity) { | |
672 jint thread_parity = _oops_do_parity; | |
673 if (thread_parity != strong_roots_parity) { | |
674 jint res = Atomic::cmpxchg(strong_roots_parity, &_oops_do_parity, thread_parity); | |
675 if (res == thread_parity) return true; | |
676 else { | |
677 guarantee(res == strong_roots_parity, "Or else what?"); | |
678 assert(SharedHeap::heap()->n_par_threads() > 0, | |
679 "Should only fail when parallel."); | |
680 return false; | |
681 } | |
682 } | |
683 assert(SharedHeap::heap()->n_par_threads() > 0, | |
684 "Should only fail when parallel."); | |
685 return false; | |
686 } | |
687 | |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
688 void Thread::oops_do(OopClosure* f, CodeBlobClosure* cf) { |
0 | 689 active_handles()->oops_do(f); |
690 // Do oop for ThreadShadow | |
691 f->do_oop((oop*)&_pending_exception); | |
692 handle_area()->oops_do(f); | |
693 } | |
694 | |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
695 void Thread::nmethods_do(CodeBlobClosure* cf) { |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
696 // no nmethods in a generic thread... |
0 | 697 } |
698 | |
699 void Thread::print_on(outputStream* st) const { | |
700 // get_priority assumes osthread initialized | |
701 if (osthread() != NULL) { | |
702 st->print("prio=%d tid=" INTPTR_FORMAT " ", get_priority(this), this); | |
703 osthread()->print_on(st); | |
704 } | |
705 debug_only(if (WizardMode) print_owned_locks_on(st);) | |
706 } | |
707 | |
708 // Thread::print_on_error() is called by fatal error handler. Don't use | |
709 // any lock or allocate memory. | |
710 void Thread::print_on_error(outputStream* st, char* buf, int buflen) const { | |
711 if (is_VM_thread()) st->print("VMThread"); | |
712 else if (is_Compiler_thread()) st->print("CompilerThread"); | |
713 else if (is_Java_thread()) st->print("JavaThread"); | |
714 else if (is_GC_task_thread()) st->print("GCTaskThread"); | |
715 else if (is_Watcher_thread()) st->print("WatcherThread"); | |
716 else if (is_ConcurrentGC_thread()) st->print("ConcurrentGCThread"); | |
717 else st->print("Thread"); | |
718 | |
719 st->print(" [stack: " PTR_FORMAT "," PTR_FORMAT "]", | |
720 _stack_base - _stack_size, _stack_base); | |
721 | |
722 if (osthread()) { | |
723 st->print(" [id=%d]", osthread()->thread_id()); | |
724 } | |
725 } | |
726 | |
727 #ifdef ASSERT | |
728 void Thread::print_owned_locks_on(outputStream* st) const { | |
729 Monitor *cur = _owned_locks; | |
730 if (cur == NULL) { | |
731 st->print(" (no locks) "); | |
732 } else { | |
733 st->print_cr(" Locks owned:"); | |
734 while(cur) { | |
735 cur->print_on(st); | |
736 cur = cur->next(); | |
737 } | |
738 } | |
739 } | |
740 | |
741 static int ref_use_count = 0; | |
742 | |
743 bool Thread::owns_locks_but_compiled_lock() const { | |
744 for(Monitor *cur = _owned_locks; cur; cur = cur->next()) { | |
745 if (cur != Compile_lock) return true; | |
746 } | |
747 return false; | |
748 } | |
749 | |
750 | |
751 #endif | |
752 | |
753 #ifndef PRODUCT | |
754 | |
755 // The flag: potential_vm_operation notifies if this particular safepoint state could potential | |
756 // invoke the vm-thread (i.e., and oop allocation). In that case, we also have to make sure that | |
757 // no threads which allow_vm_block's are held | |
758 void Thread::check_for_valid_safepoint_state(bool potential_vm_operation) { | |
759 // Check if current thread is allowed to block at a safepoint | |
760 if (!(_allow_safepoint_count == 0)) | |
761 fatal("Possible safepoint reached by thread that does not allow it"); | |
762 if (is_Java_thread() && ((JavaThread*)this)->thread_state() != _thread_in_vm) { | |
763 fatal("LEAF method calling lock?"); | |
764 } | |
765 | |
766 #ifdef ASSERT | |
767 if (potential_vm_operation && is_Java_thread() | |
768 && !Universe::is_bootstrapping()) { | |
769 // Make sure we do not hold any locks that the VM thread also uses. | |
770 // This could potentially lead to deadlocks | |
771 for(Monitor *cur = _owned_locks; cur; cur = cur->next()) { | |
772 // Threads_lock is special, since the safepoint synchronization will not start before this is | |
773 // acquired. Hence, a JavaThread cannot be holding it at a safepoint. So is VMOperationRequest_lock, | |
774 // since it is used to transfer control between JavaThreads and the VMThread | |
775 // Do not *exclude* any locks unless you are absolutly sure it is correct. Ask someone else first! | |
776 if ( (cur->allow_vm_block() && | |
777 cur != Threads_lock && | |
778 cur != Compile_lock && // Temporary: should not be necessary when we get spearate compilation | |
779 cur != VMOperationRequest_lock && | |
780 cur != VMOperationQueue_lock) || | |
781 cur->rank() == Mutex::special) { | |
782 warning("Thread holding lock at safepoint that vm can block on: %s", cur->name()); | |
783 } | |
784 } | |
785 } | |
786 | |
787 if (GCALotAtAllSafepoints) { | |
788 // We could enter a safepoint here and thus have a gc | |
789 InterfaceSupport::check_gc_alot(); | |
790 } | |
791 #endif | |
792 } | |
793 #endif | |
794 | |
795 bool Thread::is_in_stack(address adr) const { | |
796 assert(Thread::current() == this, "is_in_stack can only be called from current thread"); | |
797 address end = os::current_stack_pointer(); | |
798 if (stack_base() >= adr && adr >= end) return true; | |
799 | |
800 return false; | |
801 } | |
802 | |
803 | |
804 // We had to move these methods here, because vm threads get into ObjectSynchronizer::enter | |
805 // However, there is a note in JavaThread::is_lock_owned() about the VM threads not being | |
806 // used for compilation in the future. If that change is made, the need for these methods | |
807 // should be revisited, and they should be removed if possible. | |
808 | |
809 bool Thread::is_lock_owned(address adr) const { | |
1688
2dfd013a7465
6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents:
1608
diff
changeset
|
810 return on_local_stack(adr); |
0 | 811 } |
812 | |
813 bool Thread::set_as_starting_thread() { | |
814 // NOTE: this must be called inside the main thread. | |
815 return os::create_main_thread((JavaThread*)this); | |
816 } | |
817 | |
818 static void initialize_class(symbolHandle class_name, TRAPS) { | |
819 klassOop klass = SystemDictionary::resolve_or_fail(class_name, true, CHECK); | |
820 instanceKlass::cast(klass)->initialize(CHECK); | |
821 } | |
822 | |
823 | |
824 // Creates the initial ThreadGroup | |
825 static Handle create_initial_thread_group(TRAPS) { | |
826 klassOop k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_ThreadGroup(), true, CHECK_NH); | |
827 instanceKlassHandle klass (THREAD, k); | |
828 | |
829 Handle system_instance = klass->allocate_instance_handle(CHECK_NH); | |
830 { | |
831 JavaValue result(T_VOID); | |
832 JavaCalls::call_special(&result, | |
833 system_instance, | |
834 klass, | |
835 vmSymbolHandles::object_initializer_name(), | |
836 vmSymbolHandles::void_method_signature(), | |
837 CHECK_NH); | |
838 } | |
839 Universe::set_system_thread_group(system_instance()); | |
840 | |
841 Handle main_instance = klass->allocate_instance_handle(CHECK_NH); | |
842 { | |
843 JavaValue result(T_VOID); | |
844 Handle string = java_lang_String::create_from_str("main", CHECK_NH); | |
845 JavaCalls::call_special(&result, | |
846 main_instance, | |
847 klass, | |
848 vmSymbolHandles::object_initializer_name(), | |
849 vmSymbolHandles::threadgroup_string_void_signature(), | |
850 system_instance, | |
851 string, | |
852 CHECK_NH); | |
853 } | |
854 return main_instance; | |
855 } | |
856 | |
857 // Creates the initial Thread | |
858 static oop create_initial_thread(Handle thread_group, JavaThread* thread, TRAPS) { | |
859 klassOop k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_Thread(), true, CHECK_NULL); | |
860 instanceKlassHandle klass (THREAD, k); | |
861 instanceHandle thread_oop = klass->allocate_instance_handle(CHECK_NULL); | |
862 | |
863 java_lang_Thread::set_thread(thread_oop(), thread); | |
864 java_lang_Thread::set_priority(thread_oop(), NormPriority); | |
865 thread->set_threadObj(thread_oop()); | |
866 | |
867 Handle string = java_lang_String::create_from_str("main", CHECK_NULL); | |
868 | |
869 JavaValue result(T_VOID); | |
870 JavaCalls::call_special(&result, thread_oop, | |
871 klass, | |
872 vmSymbolHandles::object_initializer_name(), | |
873 vmSymbolHandles::threadgroup_string_void_signature(), | |
874 thread_group, | |
875 string, | |
876 CHECK_NULL); | |
877 return thread_oop(); | |
878 } | |
879 | |
880 static void call_initializeSystemClass(TRAPS) { | |
881 klassOop k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_System(), true, CHECK); | |
882 instanceKlassHandle klass (THREAD, k); | |
883 | |
884 JavaValue result(T_VOID); | |
885 JavaCalls::call_static(&result, klass, vmSymbolHandles::initializeSystemClass_name(), | |
886 vmSymbolHandles::void_method_signature(), CHECK); | |
887 } | |
888 | |
1115
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
889 #ifdef KERNEL |
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
890 static void set_jkernel_boot_classloader_hook(TRAPS) { |
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
891 klassOop k = SystemDictionary::sun_jkernel_DownloadManager_klass(); |
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
892 instanceKlassHandle klass (THREAD, k); |
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
893 |
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
894 if (k == NULL) { |
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
895 // sun.jkernel.DownloadManager may not present in the JDK; just return |
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
896 return; |
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
897 } |
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
898 |
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
899 JavaValue result(T_VOID); |
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
900 JavaCalls::call_static(&result, klass, vmSymbolHandles::setBootClassLoaderHook_name(), |
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
901 vmSymbolHandles::void_method_signature(), CHECK); |
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
902 } |
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
903 #endif // KERNEL |
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
904 |
0 | 905 static void reset_vm_info_property(TRAPS) { |
906 // the vm info string | |
907 ResourceMark rm(THREAD); | |
908 const char *vm_info = VM_Version::vm_info_string(); | |
909 | |
910 // java.lang.System class | |
911 klassOop k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_System(), true, CHECK); | |
912 instanceKlassHandle klass (THREAD, k); | |
913 | |
914 // setProperty arguments | |
915 Handle key_str = java_lang_String::create_from_str("java.vm.info", CHECK); | |
916 Handle value_str = java_lang_String::create_from_str(vm_info, CHECK); | |
917 | |
918 // return value | |
919 JavaValue r(T_OBJECT); | |
920 | |
921 // public static String setProperty(String key, String value); | |
922 JavaCalls::call_static(&r, | |
923 klass, | |
924 vmSymbolHandles::setProperty_name(), | |
925 vmSymbolHandles::string_string_string_signature(), | |
926 key_str, | |
927 value_str, | |
928 CHECK); | |
929 } | |
930 | |
931 | |
932 void JavaThread::allocate_threadObj(Handle thread_group, char* thread_name, bool daemon, TRAPS) { | |
933 assert(thread_group.not_null(), "thread group should be specified"); | |
934 assert(threadObj() == NULL, "should only create Java thread object once"); | |
935 | |
936 klassOop k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_Thread(), true, CHECK); | |
937 instanceKlassHandle klass (THREAD, k); | |
938 instanceHandle thread_oop = klass->allocate_instance_handle(CHECK); | |
939 | |
940 java_lang_Thread::set_thread(thread_oop(), this); | |
941 java_lang_Thread::set_priority(thread_oop(), NormPriority); | |
942 set_threadObj(thread_oop()); | |
943 | |
944 JavaValue result(T_VOID); | |
945 if (thread_name != NULL) { | |
946 Handle name = java_lang_String::create_from_str(thread_name, CHECK); | |
947 // Thread gets assigned specified name and null target | |
948 JavaCalls::call_special(&result, | |
949 thread_oop, | |
950 klass, | |
951 vmSymbolHandles::object_initializer_name(), | |
952 vmSymbolHandles::threadgroup_string_void_signature(), | |
953 thread_group, // Argument 1 | |
954 name, // Argument 2 | |
955 THREAD); | |
956 } else { | |
957 // Thread gets assigned name "Thread-nnn" and null target | |
958 // (java.lang.Thread doesn't have a constructor taking only a ThreadGroup argument) | |
959 JavaCalls::call_special(&result, | |
960 thread_oop, | |
961 klass, | |
962 vmSymbolHandles::object_initializer_name(), | |
963 vmSymbolHandles::threadgroup_runnable_void_signature(), | |
964 thread_group, // Argument 1 | |
965 Handle(), // Argument 2 | |
966 THREAD); | |
967 } | |
968 | |
969 | |
970 if (daemon) { | |
971 java_lang_Thread::set_daemon(thread_oop()); | |
972 } | |
973 | |
974 if (HAS_PENDING_EXCEPTION) { | |
975 return; | |
976 } | |
977 | |
1142 | 978 KlassHandle group(this, SystemDictionary::ThreadGroup_klass()); |
0 | 979 Handle threadObj(this, this->threadObj()); |
980 | |
981 JavaCalls::call_special(&result, | |
982 thread_group, | |
983 group, | |
984 vmSymbolHandles::add_method_name(), | |
985 vmSymbolHandles::thread_void_signature(), | |
986 threadObj, // Arg 1 | |
987 THREAD); | |
988 | |
989 | |
990 } | |
991 | |
992 // NamedThread -- non-JavaThread subclasses with multiple | |
993 // uniquely named instances should derive from this. | |
994 NamedThread::NamedThread() : Thread() { | |
995 _name = NULL; | |
1119
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
996 _processed_thread = NULL; |
0 | 997 } |
998 | |
999 NamedThread::~NamedThread() { | |
1000 if (_name != NULL) { | |
1001 FREE_C_HEAP_ARRAY(char, _name); | |
1002 _name = NULL; | |
1003 } | |
1004 } | |
1005 | |
1006 void NamedThread::set_name(const char* format, ...) { | |
1007 guarantee(_name == NULL, "Only get to set name once."); | |
1008 _name = NEW_C_HEAP_ARRAY(char, max_name_len); | |
1009 guarantee(_name != NULL, "alloc failure"); | |
1010 va_list ap; | |
1011 va_start(ap, format); | |
1012 jio_vsnprintf(_name, max_name_len, format, ap); | |
1013 va_end(ap); | |
1014 } | |
1015 | |
1016 // ======= WatcherThread ======== | |
1017 | |
1018 // The watcher thread exists to simulate timer interrupts. It should | |
1019 // be replaced by an abstraction over whatever native support for | |
1020 // timer interrupts exists on the platform. | |
1021 | |
1022 WatcherThread* WatcherThread::_watcher_thread = NULL; | |
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
1023 volatile bool WatcherThread::_should_terminate = false; |
0 | 1024 |
1025 WatcherThread::WatcherThread() : Thread() { | |
1026 assert(watcher_thread() == NULL, "we can only allocate one WatcherThread"); | |
1027 if (os::create_thread(this, os::watcher_thread)) { | |
1028 _watcher_thread = this; | |
1029 | |
1030 // Set the watcher thread to the highest OS priority which should not be | |
1031 // used, unless a Java thread with priority java.lang.Thread.MAX_PRIORITY | |
1032 // is created. The only normal thread using this priority is the reference | |
1033 // handler thread, which runs for very short intervals only. | |
1034 // If the VMThread's priority is not lower than the WatcherThread profiling | |
1035 // will be inaccurate. | |
1036 os::set_priority(this, MaxPriority); | |
1037 if (!DisableStartThread) { | |
1038 os::start_thread(this); | |
1039 } | |
1040 } | |
1041 } | |
1042 | |
1043 void WatcherThread::run() { | |
1044 assert(this == watcher_thread(), "just checking"); | |
1045 | |
1046 this->record_stack_base_and_size(); | |
1047 this->initialize_thread_local_storage(); | |
1048 this->set_active_handles(JNIHandleBlock::allocate_block()); | |
1049 while(!_should_terminate) { | |
1050 assert(watcher_thread() == Thread::current(), "thread consistency check"); | |
1051 assert(watcher_thread() == this, "thread consistency check"); | |
1052 | |
1053 // Calculate how long it'll be until the next PeriodicTask work | |
1054 // should be done, and sleep that amount of time. | |
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
1055 size_t time_to_wait = PeriodicTask::time_to_wait(); |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
1056 |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
1057 // we expect this to timeout - we only ever get unparked when |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
1058 // we should terminate |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
1059 { |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
1060 OSThreadWaitState osts(this->osthread(), false /* not Object.wait() */); |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
1061 |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
1062 jlong prev_time = os::javaTimeNanos(); |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
1063 for (;;) { |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
1064 int res= _SleepEvent->park(time_to_wait); |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
1065 if (res == OS_TIMEOUT || _should_terminate) |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
1066 break; |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
1067 // spurious wakeup of some kind |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
1068 jlong now = os::javaTimeNanos(); |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
1069 time_to_wait -= (now - prev_time) / 1000000; |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
1070 if (time_to_wait <= 0) |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
1071 break; |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
1072 prev_time = now; |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
1073 } |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
1074 } |
0 | 1075 |
1076 if (is_error_reported()) { | |
1077 // A fatal error has happened, the error handler(VMError::report_and_die) | |
1078 // should abort JVM after creating an error log file. However in some | |
1079 // rare cases, the error handler itself might deadlock. Here we try to | |
1080 // kill JVM if the fatal error handler fails to abort in 2 minutes. | |
1081 // | |
1082 // This code is in WatcherThread because WatcherThread wakes up | |
1083 // periodically so the fatal error handler doesn't need to do anything; | |
1084 // also because the WatcherThread is less likely to crash than other | |
1085 // threads. | |
1086 | |
1087 for (;;) { | |
1088 if (!ShowMessageBoxOnError | |
1089 && (OnError == NULL || OnError[0] == '\0') | |
1090 && Arguments::abort_hook() == NULL) { | |
1091 os::sleep(this, 2 * 60 * 1000, false); | |
1092 fdStream err(defaultStream::output_fd()); | |
1093 err.print_raw_cr("# [ timer expired, abort... ]"); | |
1094 // skip atexit/vm_exit/vm_abort hooks | |
1095 os::die(); | |
1096 } | |
1097 | |
1098 // Wake up 5 seconds later, the fatal handler may reset OnError or | |
1099 // ShowMessageBoxOnError when it is ready to abort. | |
1100 os::sleep(this, 5 * 1000, false); | |
1101 } | |
1102 } | |
1103 | |
1104 PeriodicTask::real_time_tick(time_to_wait); | |
1105 | |
1106 // If we have no more tasks left due to dynamic disenrollment, | |
1107 // shut down the thread since we don't currently support dynamic enrollment | |
1108 if (PeriodicTask::num_tasks() == 0) { | |
1109 _should_terminate = true; | |
1110 } | |
1111 } | |
1112 | |
1113 // Signal that it is terminated | |
1114 { | |
1115 MutexLockerEx mu(Terminator_lock, Mutex::_no_safepoint_check_flag); | |
1116 _watcher_thread = NULL; | |
1117 Terminator_lock->notify(); | |
1118 } | |
1119 | |
1120 // Thread destructor usually does this.. | |
1121 ThreadLocalStorage::set_thread(NULL); | |
1122 } | |
1123 | |
1124 void WatcherThread::start() { | |
1125 if (watcher_thread() == NULL) { | |
1126 _should_terminate = false; | |
1127 // Create the single instance of WatcherThread | |
1128 new WatcherThread(); | |
1129 } | |
1130 } | |
1131 | |
1132 void WatcherThread::stop() { | |
1133 // it is ok to take late safepoints here, if needed | |
1134 MutexLocker mu(Terminator_lock); | |
1135 _should_terminate = true; | |
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
1136 OrderAccess::fence(); // ensure WatcherThread sees update in main loop |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
1137 |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
1138 Thread* watcher = watcher_thread(); |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
1139 if (watcher != NULL) |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
1140 watcher->_SleepEvent->unpark(); |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
1141 |
0 | 1142 while(watcher_thread() != NULL) { |
1143 // This wait should make safepoint checks, wait without a timeout, | |
1144 // and wait as a suspend-equivalent condition. | |
1145 // | |
1146 // Note: If the FlatProfiler is running, then this thread is waiting | |
1147 // for the WatcherThread to terminate and the WatcherThread, via the | |
1148 // FlatProfiler task, is waiting for the external suspend request on | |
1149 // this thread to complete. wait_for_ext_suspend_completion() will | |
1150 // eventually timeout, but that takes time. Making this wait a | |
1151 // suspend-equivalent condition solves that timeout problem. | |
1152 // | |
1153 Terminator_lock->wait(!Mutex::_no_safepoint_check_flag, 0, | |
1154 Mutex::_as_suspend_equivalent_flag); | |
1155 } | |
1156 } | |
1157 | |
1158 void WatcherThread::print_on(outputStream* st) const { | |
1159 st->print("\"%s\" ", name()); | |
1160 Thread::print_on(st); | |
1161 st->cr(); | |
1162 } | |
1163 | |
1164 // ======= JavaThread ======== | |
1165 | |
1166 // A JavaThread is a normal Java thread | |
1167 | |
1168 void JavaThread::initialize() { | |
1169 // Initialize fields | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1170 |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1171 // Set the claimed par_id to -1 (ie not claiming any par_ids) |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1172 set_claimed_par_id(-1); |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1173 |
0 | 1174 set_saved_exception_pc(NULL); |
1175 set_threadObj(NULL); | |
1176 _anchor.clear(); | |
1177 set_entry_point(NULL); | |
1178 set_jni_functions(jni_functions()); | |
1179 set_callee_target(NULL); | |
1180 set_vm_result(NULL); | |
1181 set_vm_result_2(NULL); | |
1182 set_vframe_array_head(NULL); | |
1183 set_vframe_array_last(NULL); | |
1184 set_deferred_locals(NULL); | |
1185 set_deopt_mark(NULL); | |
1186 clear_must_deopt_id(); | |
1187 set_monitor_chunks(NULL); | |
1188 set_next(NULL); | |
1189 set_thread_state(_thread_new); | |
1190 _terminated = _not_terminated; | |
1191 _privileged_stack_top = NULL; | |
1192 _array_for_gc = NULL; | |
1193 _suspend_equivalent = false; | |
1194 _in_deopt_handler = 0; | |
1195 _doing_unsafe_access = false; | |
1196 _stack_guard_state = stack_guard_unused; | |
1197 _exception_oop = NULL; | |
1198 _exception_pc = 0; | |
1199 _exception_handler_pc = 0; | |
1200 _exception_stack_size = 0; | |
1201 _jvmti_thread_state= NULL; | |
1213
6deeaebad47a
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
1166
diff
changeset
|
1202 _should_post_on_exceptions_flag = JNI_FALSE; |
0 | 1203 _jvmti_get_loaded_classes_closure = NULL; |
1204 _interp_only_mode = 0; | |
1205 _special_runtime_exit_condition = _no_async_condition; | |
1206 _pending_async_exception = NULL; | |
1207 _is_compiling = false; | |
1208 _thread_stat = NULL; | |
1209 _thread_stat = new ThreadStatistics(); | |
1210 _blocked_on_compilation = false; | |
1211 _jni_active_critical = 0; | |
1212 _do_not_unlock_if_synchronized = false; | |
1213 _cached_monitor_info = NULL; | |
1214 _parker = Parker::Allocate(this) ; | |
1215 | |
1216 #ifndef PRODUCT | |
1217 _jmp_ring_index = 0; | |
1218 for (int ji = 0 ; ji < jump_ring_buffer_size ; ji++ ) { | |
1219 record_jump(NULL, NULL, NULL, 0); | |
1220 } | |
1221 #endif /* PRODUCT */ | |
1222 | |
1223 set_thread_profiler(NULL); | |
1224 if (FlatProfiler::is_active()) { | |
1225 // This is where we would decide to either give each thread it's own profiler | |
1226 // or use one global one from FlatProfiler, | |
1227 // or up to some count of the number of profiled threads, etc. | |
1228 ThreadProfiler* pp = new ThreadProfiler(); | |
1229 pp->engage(); | |
1230 set_thread_profiler(pp); | |
1231 } | |
1232 | |
1233 // Setup safepoint state info for this thread | |
1234 ThreadSafepointState::create(this); | |
1235 | |
1236 debug_only(_java_call_counter = 0); | |
1237 | |
1238 // JVMTI PopFrame support | |
1239 _popframe_condition = popframe_inactive; | |
1240 _popframe_preserved_args = NULL; | |
1241 _popframe_preserved_args_size = 0; | |
1242 | |
1243 pd_initialize(); | |
1244 } | |
1245 | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1246 #ifndef SERIALGC |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1247 SATBMarkQueueSet JavaThread::_satb_mark_queue_set; |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1248 DirtyCardQueueSet JavaThread::_dirty_card_queue_set; |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1249 #endif // !SERIALGC |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1250 |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1251 JavaThread::JavaThread(bool is_attaching) : |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1252 Thread() |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1253 #ifndef SERIALGC |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1254 , _satb_mark_queue(&_satb_mark_queue_set), |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1255 _dirty_card_queue(&_dirty_card_queue_set) |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1256 #endif // !SERIALGC |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1257 { |
0 | 1258 initialize(); |
1259 _is_attaching = is_attaching; | |
1027
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
997
diff
changeset
|
1260 assert(_deferred_card_mark.is_empty(), "Default MemRegion ctor"); |
0 | 1261 } |
1262 | |
1263 bool JavaThread::reguard_stack(address cur_sp) { | |
1264 if (_stack_guard_state != stack_guard_yellow_disabled) { | |
1265 return true; // Stack already guarded or guard pages not needed. | |
1266 } | |
1267 | |
1268 if (register_stack_overflow()) { | |
1269 // For those architectures which have separate register and | |
1270 // memory stacks, we must check the register stack to see if | |
1271 // it has overflowed. | |
1272 return false; | |
1273 } | |
1274 | |
1275 // Java code never executes within the yellow zone: the latter is only | |
1276 // there to provoke an exception during stack banging. If java code | |
1277 // is executing there, either StackShadowPages should be larger, or | |
1278 // some exception code in c1, c2 or the interpreter isn't unwinding | |
1279 // when it should. | |
1280 guarantee(cur_sp > stack_yellow_zone_base(), "not enough space to reguard - increase StackShadowPages"); | |
1281 | |
1282 enable_stack_yellow_zone(); | |
1283 return true; | |
1284 } | |
1285 | |
1286 bool JavaThread::reguard_stack(void) { | |
1287 return reguard_stack(os::current_stack_pointer()); | |
1288 } | |
1289 | |
1290 | |
1291 void JavaThread::block_if_vm_exited() { | |
1292 if (_terminated == _vm_exited) { | |
1293 // _vm_exited is set at safepoint, and Threads_lock is never released | |
1294 // we will block here forever | |
1295 Threads_lock->lock_without_safepoint_check(); | |
1296 ShouldNotReachHere(); | |
1297 } | |
1298 } | |
1299 | |
1300 | |
1301 // Remove this ifdef when C1 is ported to the compiler interface. | |
1302 static void compiler_thread_entry(JavaThread* thread, TRAPS); | |
1303 | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1304 JavaThread::JavaThread(ThreadFunction entry_point, size_t stack_sz) : |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1305 Thread() |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1306 #ifndef SERIALGC |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1307 , _satb_mark_queue(&_satb_mark_queue_set), |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1308 _dirty_card_queue(&_dirty_card_queue_set) |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1309 #endif // !SERIALGC |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1310 { |
0 | 1311 if (TraceThreadEvents) { |
1312 tty->print_cr("creating thread %p", this); | |
1313 } | |
1314 initialize(); | |
1315 _is_attaching = false; | |
1316 set_entry_point(entry_point); | |
1317 // Create the native thread itself. | |
1318 // %note runtime_23 | |
1319 os::ThreadType thr_type = os::java_thread; | |
1320 thr_type = entry_point == &compiler_thread_entry ? os::compiler_thread : | |
1321 os::java_thread; | |
1322 os::create_thread(this, thr_type, stack_sz); | |
1323 | |
1324 // The _osthread may be NULL here because we ran out of memory (too many threads active). | |
1325 // We need to throw and OutOfMemoryError - however we cannot do this here because the caller | |
1326 // may hold a lock and all locks must be unlocked before throwing the exception (throwing | |
1327 // the exception consists of creating the exception object & initializing it, initialization | |
1328 // will leave the VM via a JavaCall and then all locks must be unlocked). | |
1329 // | |
1330 // The thread is still suspended when we reach here. Thread must be explicit started | |
1331 // by creator! Furthermore, the thread must also explicitly be added to the Threads list | |
1332 // by calling Threads:add. The reason why this is not done here, is because the thread | |
1333 // object must be fully initialized (take a look at JVM_Start) | |
1334 } | |
1335 | |
1336 JavaThread::~JavaThread() { | |
1337 if (TraceThreadEvents) { | |
1338 tty->print_cr("terminate thread %p", this); | |
1339 } | |
1340 | |
1341 // JSR166 -- return the parker to the free list | |
1342 Parker::Release(_parker); | |
1343 _parker = NULL ; | |
1344 | |
1345 // Free any remaining previous UnrollBlock | |
1346 vframeArray* old_array = vframe_array_last(); | |
1347 | |
1348 if (old_array != NULL) { | |
1349 Deoptimization::UnrollBlock* old_info = old_array->unroll_block(); | |
1350 old_array->set_unroll_block(NULL); | |
1351 delete old_info; | |
1352 delete old_array; | |
1353 } | |
1354 | |
1355 GrowableArray<jvmtiDeferredLocalVariableSet*>* deferred = deferred_locals(); | |
1356 if (deferred != NULL) { | |
1357 // This can only happen if thread is destroyed before deoptimization occurs. | |
1358 assert(deferred->length() != 0, "empty array!"); | |
1359 do { | |
1360 jvmtiDeferredLocalVariableSet* dlv = deferred->at(0); | |
1361 deferred->remove_at(0); | |
1362 // individual jvmtiDeferredLocalVariableSet are CHeapObj's | |
1363 delete dlv; | |
1364 } while (deferred->length() != 0); | |
1365 delete deferred; | |
1366 } | |
1367 | |
1368 // All Java related clean up happens in exit | |
1369 ThreadSafepointState::destroy(this); | |
1370 if (_thread_profiler != NULL) delete _thread_profiler; | |
1371 if (_thread_stat != NULL) delete _thread_stat; | |
1372 } | |
1373 | |
1374 | |
1375 // The first routine called by a new Java thread | |
1376 void JavaThread::run() { | |
1377 // initialize thread-local alloc buffer related fields | |
1378 this->initialize_tlab(); | |
1379 | |
1380 // used to test validitity of stack trace backs | |
1381 this->record_base_of_stack_pointer(); | |
1382 | |
1383 // Record real stack base and size. | |
1384 this->record_stack_base_and_size(); | |
1385 | |
1386 // Initialize thread local storage; set before calling MutexLocker | |
1387 this->initialize_thread_local_storage(); | |
1388 | |
1389 this->create_stack_guard_pages(); | |
1390 | |
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
1391 this->cache_global_variables(); |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
1392 |
0 | 1393 // Thread is now sufficient initialized to be handled by the safepoint code as being |
1394 // in the VM. Change thread state from _thread_new to _thread_in_vm | |
1395 ThreadStateTransition::transition_and_fence(this, _thread_new, _thread_in_vm); | |
1396 | |
1397 assert(JavaThread::current() == this, "sanity check"); | |
1398 assert(!Thread::current()->owns_locks(), "sanity check"); | |
1399 | |
1400 DTRACE_THREAD_PROBE(start, this); | |
1401 | |
1402 // This operation might block. We call that after all safepoint checks for a new thread has | |
1403 // been completed. | |
1404 this->set_active_handles(JNIHandleBlock::allocate_block()); | |
1405 | |
1406 if (JvmtiExport::should_post_thread_life()) { | |
1407 JvmtiExport::post_thread_start(this); | |
1408 } | |
1409 | |
1410 // We call another function to do the rest so we are sure that the stack addresses used | |
1411 // from there will be lower than the stack base just computed | |
1412 thread_main_inner(); | |
1413 | |
1414 // Note, thread is no longer valid at this point! | |
1415 } | |
1416 | |
1417 | |
1418 void JavaThread::thread_main_inner() { | |
1419 assert(JavaThread::current() == this, "sanity check"); | |
1420 assert(this->threadObj() != NULL, "just checking"); | |
1421 | |
1422 // Execute thread entry point. If this thread is being asked to restart, | |
1423 // or has been stopped before starting, do not reexecute entry point. | |
1424 // Note: Due to JVM_StopThread we can have pending exceptions already! | |
1425 if (!this->has_pending_exception() && !java_lang_Thread::is_stillborn(this->threadObj())) { | |
1426 // enter the thread's entry point only if we have no pending exceptions | |
1427 HandleMark hm(this); | |
1428 this->entry_point()(this, this); | |
1429 } | |
1430 | |
1431 DTRACE_THREAD_PROBE(stop, this); | |
1432 | |
1433 this->exit(false); | |
1434 delete this; | |
1435 } | |
1436 | |
1437 | |
1438 static void ensure_join(JavaThread* thread) { | |
1439 // We do not need to grap the Threads_lock, since we are operating on ourself. | |
1440 Handle threadObj(thread, thread->threadObj()); | |
1441 assert(threadObj.not_null(), "java thread object must exist"); | |
1442 ObjectLocker lock(threadObj, thread); | |
1443 // Ignore pending exception (ThreadDeath), since we are exiting anyway | |
1444 thread->clear_pending_exception(); | |
1445 // It is of profound importance that we set the stillborn bit and reset the thread object, | |
1446 // before we do the notify. Since, changing these two variable will make JVM_IsAlive return | |
1447 // false. So in case another thread is doing a join on this thread , it will detect that the thread | |
1448 // is dead when it gets notified. | |
1449 java_lang_Thread::set_stillborn(threadObj()); | |
1450 // Thread is exiting. So set thread_status field in java.lang.Thread class to TERMINATED. | |
1451 java_lang_Thread::set_thread_status(threadObj(), java_lang_Thread::TERMINATED); | |
1452 java_lang_Thread::set_thread(threadObj(), NULL); | |
1453 lock.notify_all(thread); | |
1454 // Ignore pending exception (ThreadDeath), since we are exiting anyway | |
1455 thread->clear_pending_exception(); | |
1456 } | |
1457 | |
441
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1458 |
0 | 1459 // For any new cleanup additions, please check to see if they need to be applied to |
1460 // cleanup_failed_attach_current_thread as well. | |
1461 void JavaThread::exit(bool destroy_vm, ExitType exit_type) { | |
1462 assert(this == JavaThread::current(), "thread consistency check"); | |
1463 if (!InitializeJavaLangSystem) return; | |
1464 | |
1465 HandleMark hm(this); | |
1466 Handle uncaught_exception(this, this->pending_exception()); | |
1467 this->clear_pending_exception(); | |
1468 Handle threadObj(this, this->threadObj()); | |
1469 assert(threadObj.not_null(), "Java thread object should be created"); | |
1470 | |
1471 if (get_thread_profiler() != NULL) { | |
1472 get_thread_profiler()->disengage(); | |
1473 ResourceMark rm; | |
1474 get_thread_profiler()->print(get_thread_name()); | |
1475 } | |
1476 | |
1477 | |
1478 // FIXIT: This code should be moved into else part, when reliable 1.2/1.3 check is in place | |
1479 { | |
1480 EXCEPTION_MARK; | |
1481 | |
1482 CLEAR_PENDING_EXCEPTION; | |
1483 } | |
1484 // FIXIT: The is_null check is only so it works better on JDK1.2 VM's. This | |
1485 // has to be fixed by a runtime query method | |
1486 if (!destroy_vm || JDK_Version::is_jdk12x_version()) { | |
1487 // JSR-166: change call from from ThreadGroup.uncaughtException to | |
1488 // java.lang.Thread.dispatchUncaughtException | |
1489 if (uncaught_exception.not_null()) { | |
1490 Handle group(this, java_lang_Thread::threadGroup(threadObj())); | |
1491 Events::log("uncaught exception INTPTR_FORMAT " " INTPTR_FORMAT " " INTPTR_FORMAT", | |
1492 (address)uncaught_exception(), (address)threadObj(), (address)group()); | |
1493 { | |
1494 EXCEPTION_MARK; | |
1495 // Check if the method Thread.dispatchUncaughtException() exists. If so | |
1496 // call it. Otherwise we have an older library without the JSR-166 changes, | |
1497 // so call ThreadGroup.uncaughtException() | |
1498 KlassHandle recvrKlass(THREAD, threadObj->klass()); | |
1499 CallInfo callinfo; | |
1142 | 1500 KlassHandle thread_klass(THREAD, SystemDictionary::Thread_klass()); |
0 | 1501 LinkResolver::resolve_virtual_call(callinfo, threadObj, recvrKlass, thread_klass, |
1502 vmSymbolHandles::dispatchUncaughtException_name(), | |
1503 vmSymbolHandles::throwable_void_signature(), | |
1504 KlassHandle(), false, false, THREAD); | |
1505 CLEAR_PENDING_EXCEPTION; | |
1506 methodHandle method = callinfo.selected_method(); | |
1507 if (method.not_null()) { | |
1508 JavaValue result(T_VOID); | |
1509 JavaCalls::call_virtual(&result, | |
1510 threadObj, thread_klass, | |
1511 vmSymbolHandles::dispatchUncaughtException_name(), | |
1512 vmSymbolHandles::throwable_void_signature(), | |
1513 uncaught_exception, | |
1514 THREAD); | |
1515 } else { | |
1142 | 1516 KlassHandle thread_group(THREAD, SystemDictionary::ThreadGroup_klass()); |
0 | 1517 JavaValue result(T_VOID); |
1518 JavaCalls::call_virtual(&result, | |
1519 group, thread_group, | |
1520 vmSymbolHandles::uncaughtException_name(), | |
1521 vmSymbolHandles::thread_throwable_void_signature(), | |
1522 threadObj, // Arg 1 | |
1523 uncaught_exception, // Arg 2 | |
1524 THREAD); | |
1525 } | |
1526 CLEAR_PENDING_EXCEPTION; | |
1527 } | |
1528 } | |
1529 | |
1530 // Call Thread.exit(). We try 3 times in case we got another Thread.stop during | |
1531 // the execution of the method. If that is not enough, then we don't really care. Thread.stop | |
1532 // is deprecated anyhow. | |
1533 { int count = 3; | |
1534 while (java_lang_Thread::threadGroup(threadObj()) != NULL && (count-- > 0)) { | |
1535 EXCEPTION_MARK; | |
1536 JavaValue result(T_VOID); | |
1142 | 1537 KlassHandle thread_klass(THREAD, SystemDictionary::Thread_klass()); |
0 | 1538 JavaCalls::call_virtual(&result, |
1539 threadObj, thread_klass, | |
1540 vmSymbolHandles::exit_method_name(), | |
1541 vmSymbolHandles::void_method_signature(), | |
1542 THREAD); | |
1543 CLEAR_PENDING_EXCEPTION; | |
1544 } | |
1545 } | |
1546 | |
1547 // notify JVMTI | |
1548 if (JvmtiExport::should_post_thread_life()) { | |
1549 JvmtiExport::post_thread_end(this); | |
1550 } | |
1551 | |
1552 // We have notified the agents that we are exiting, before we go on, | |
1553 // we must check for a pending external suspend request and honor it | |
1554 // in order to not surprise the thread that made the suspend request. | |
1555 while (true) { | |
1556 { | |
1557 MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag); | |
1558 if (!is_external_suspend()) { | |
1559 set_terminated(_thread_exiting); | |
1560 ThreadService::current_thread_exiting(this); | |
1561 break; | |
1562 } | |
1563 // Implied else: | |
1564 // Things get a little tricky here. We have a pending external | |
1565 // suspend request, but we are holding the SR_lock so we | |
1566 // can't just self-suspend. So we temporarily drop the lock | |
1567 // and then self-suspend. | |
1568 } | |
1569 | |
1570 ThreadBlockInVM tbivm(this); | |
1571 java_suspend_self(); | |
1572 | |
1573 // We're done with this suspend request, but we have to loop around | |
1574 // and check again. Eventually we will get SR_lock without a pending | |
1575 // external suspend request and will be able to mark ourselves as | |
1576 // exiting. | |
1577 } | |
1578 // no more external suspends are allowed at this point | |
1579 } else { | |
1580 // before_exit() has already posted JVMTI THREAD_END events | |
1581 } | |
1582 | |
1583 // Notify waiters on thread object. This has to be done after exit() is called | |
1584 // on the thread (if the thread is the last thread in a daemon ThreadGroup the | |
1585 // group should have the destroyed bit set before waiters are notified). | |
1586 ensure_join(this); | |
1587 assert(!this->has_pending_exception(), "ensure_join should have cleared"); | |
1588 | |
1589 // 6282335 JNI DetachCurrentThread spec states that all Java monitors | |
1590 // held by this thread must be released. A detach operation must only | |
1591 // get here if there are no Java frames on the stack. Therefore, any | |
1592 // owned monitors at this point MUST be JNI-acquired monitors which are | |
1593 // pre-inflated and in the monitor cache. | |
1594 // | |
1595 // ensure_join() ignores IllegalThreadStateExceptions, and so does this. | |
1596 if (exit_type == jni_detach && JNIDetachReleasesMonitors) { | |
1597 assert(!this->has_last_Java_frame(), "detaching with Java frames?"); | |
1598 ObjectSynchronizer::release_monitors_owned_by_thread(this); | |
1599 assert(!this->has_pending_exception(), "release_monitors should have cleared"); | |
1600 } | |
1601 | |
1602 // These things needs to be done while we are still a Java Thread. Make sure that thread | |
1603 // is in a consistent state, in case GC happens | |
1604 assert(_privileged_stack_top == NULL, "must be NULL when we get here"); | |
1605 | |
1606 if (active_handles() != NULL) { | |
1607 JNIHandleBlock* block = active_handles(); | |
1608 set_active_handles(NULL); | |
1609 JNIHandleBlock::release_block(block); | |
1610 } | |
1611 | |
1612 if (free_handle_block() != NULL) { | |
1613 JNIHandleBlock* block = free_handle_block(); | |
1614 set_free_handle_block(NULL); | |
1615 JNIHandleBlock::release_block(block); | |
1616 } | |
1617 | |
1618 // These have to be removed while this is still a valid thread. | |
1619 remove_stack_guard_pages(); | |
1620 | |
1621 if (UseTLAB) { | |
1622 tlab().make_parsable(true); // retire TLAB | |
1623 } | |
1624 | |
49
31000d79ec71
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
0
diff
changeset
|
1625 if (jvmti_thread_state() != NULL) { |
31000d79ec71
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
0
diff
changeset
|
1626 JvmtiExport::cleanup_thread(this); |
31000d79ec71
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
0
diff
changeset
|
1627 } |
31000d79ec71
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
0
diff
changeset
|
1628 |
441
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1629 #ifndef SERIALGC |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1630 // We must flush G1-related buffers before removing a thread from |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1631 // the list of active threads. |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1632 if (UseG1GC) { |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1633 flush_barrier_queues(); |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1634 } |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1635 #endif |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1636 |
0 | 1637 // Remove from list of active threads list, and notify VM thread if we are the last non-daemon thread |
1638 Threads::remove(this); | |
1639 } | |
1640 | |
441
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1641 #ifndef SERIALGC |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1642 // Flush G1-related queues. |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1643 void JavaThread::flush_barrier_queues() { |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1644 satb_mark_queue().flush(); |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1645 dirty_card_queue().flush(); |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1646 } |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1647 #endif |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1648 |
0 | 1649 void JavaThread::cleanup_failed_attach_current_thread() { |
441
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1650 if (get_thread_profiler() != NULL) { |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1651 get_thread_profiler()->disengage(); |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1652 ResourceMark rm; |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1653 get_thread_profiler()->print(get_thread_name()); |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1654 } |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1655 |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1656 if (active_handles() != NULL) { |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1657 JNIHandleBlock* block = active_handles(); |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1658 set_active_handles(NULL); |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1659 JNIHandleBlock::release_block(block); |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1660 } |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1661 |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1662 if (free_handle_block() != NULL) { |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1663 JNIHandleBlock* block = free_handle_block(); |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1664 set_free_handle_block(NULL); |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1665 JNIHandleBlock::release_block(block); |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1666 } |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1667 |
1290
c8a467bf56ad
6914050: jvm assertion "guard pages must be in use" in -Xcomp mode
coleenp
parents:
1213
diff
changeset
|
1668 // These have to be removed while this is still a valid thread. |
c8a467bf56ad
6914050: jvm assertion "guard pages must be in use" in -Xcomp mode
coleenp
parents:
1213
diff
changeset
|
1669 remove_stack_guard_pages(); |
c8a467bf56ad
6914050: jvm assertion "guard pages must be in use" in -Xcomp mode
coleenp
parents:
1213
diff
changeset
|
1670 |
441
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1671 if (UseTLAB) { |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1672 tlab().make_parsable(true); // retire TLAB, if any |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1673 } |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1674 |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1675 #ifndef SERIALGC |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1676 if (UseG1GC) { |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1677 flush_barrier_queues(); |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1678 } |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1679 #endif |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1680 |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1681 Threads::remove(this); |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1682 delete this; |
0 | 1683 } |
1684 | |
1685 | |
441
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1686 |
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1687 |
0 | 1688 JavaThread* JavaThread::active() { |
1689 Thread* thread = ThreadLocalStorage::thread(); | |
1690 assert(thread != NULL, "just checking"); | |
1691 if (thread->is_Java_thread()) { | |
1692 return (JavaThread*) thread; | |
1693 } else { | |
1694 assert(thread->is_VM_thread(), "this must be a vm thread"); | |
1695 VM_Operation* op = ((VMThread*) thread)->vm_operation(); | |
1696 JavaThread *ret=op == NULL ? NULL : (JavaThread *)op->calling_thread(); | |
1697 assert(ret->is_Java_thread(), "must be a Java thread"); | |
1698 return ret; | |
1699 } | |
1700 } | |
1701 | |
1702 bool JavaThread::is_lock_owned(address adr) const { | |
702
b9fba36710f2
6699669: Hotspot server leaves synchronized block with monitor in bad state
xlu
parents:
669
diff
changeset
|
1703 if (Thread::is_lock_owned(adr)) return true; |
0 | 1704 |
1705 for (MonitorChunk* chunk = monitor_chunks(); chunk != NULL; chunk = chunk->next()) { | |
1706 if (chunk->contains(adr)) return true; | |
1707 } | |
1708 | |
1709 return false; | |
1710 } | |
1711 | |
1712 | |
1713 void JavaThread::add_monitor_chunk(MonitorChunk* chunk) { | |
1714 chunk->set_next(monitor_chunks()); | |
1715 set_monitor_chunks(chunk); | |
1716 } | |
1717 | |
1718 void JavaThread::remove_monitor_chunk(MonitorChunk* chunk) { | |
1719 guarantee(monitor_chunks() != NULL, "must be non empty"); | |
1720 if (monitor_chunks() == chunk) { | |
1721 set_monitor_chunks(chunk->next()); | |
1722 } else { | |
1723 MonitorChunk* prev = monitor_chunks(); | |
1724 while (prev->next() != chunk) prev = prev->next(); | |
1725 prev->set_next(chunk->next()); | |
1726 } | |
1727 } | |
1728 | |
1729 // JVM support. | |
1730 | |
1731 // Note: this function shouldn't block if it's called in | |
1732 // _thread_in_native_trans state (such as from | |
1733 // check_special_condition_for_native_trans()). | |
1734 void JavaThread::check_and_handle_async_exceptions(bool check_unsafe_error) { | |
1735 | |
1736 if (has_last_Java_frame() && has_async_condition()) { | |
1737 // If we are at a polling page safepoint (not a poll return) | |
1738 // then we must defer async exception because live registers | |
1739 // will be clobbered by the exception path. Poll return is | |
1740 // ok because the call we a returning from already collides | |
1741 // with exception handling registers and so there is no issue. | |
1742 // (The exception handling path kills call result registers but | |
1743 // this is ok since the exception kills the result anyway). | |
1744 | |
1745 if (is_at_poll_safepoint()) { | |
1746 // if the code we are returning to has deoptimized we must defer | |
1747 // the exception otherwise live registers get clobbered on the | |
1748 // exception path before deoptimization is able to retrieve them. | |
1749 // | |
1750 RegisterMap map(this, false); | |
1751 frame caller_fr = last_frame().sender(&map); | |
1752 assert(caller_fr.is_compiled_frame(), "what?"); | |
1753 if (caller_fr.is_deoptimized_frame()) { | |
1754 if (TraceExceptions) { | |
1755 ResourceMark rm; | |
1756 tty->print_cr("deferred async exception at compiled safepoint"); | |
1757 } | |
1758 return; | |
1759 } | |
1760 } | |
1761 } | |
1762 | |
1763 JavaThread::AsyncRequests condition = clear_special_runtime_exit_condition(); | |
1764 if (condition == _no_async_condition) { | |
1765 // Conditions have changed since has_special_runtime_exit_condition() | |
1766 // was called: | |
1767 // - if we were here only because of an external suspend request, | |
1768 // then that was taken care of above (or cancelled) so we are done | |
1769 // - if we were here because of another async request, then it has | |
1770 // been cleared between the has_special_runtime_exit_condition() | |
1771 // and now so again we are done | |
1772 return; | |
1773 } | |
1774 | |
1775 // Check for pending async. exception | |
1776 if (_pending_async_exception != NULL) { | |
1777 // Only overwrite an already pending exception, if it is not a threadDeath. | |
1142 | 1778 if (!has_pending_exception() || !pending_exception()->is_a(SystemDictionary::ThreadDeath_klass())) { |
0 | 1779 |
1780 // We cannot call Exceptions::_throw(...) here because we cannot block | |
1781 set_pending_exception(_pending_async_exception, __FILE__, __LINE__); | |
1782 | |
1783 if (TraceExceptions) { | |
1784 ResourceMark rm; | |
1785 tty->print("Async. exception installed at runtime exit (" INTPTR_FORMAT ")", this); | |
1786 if (has_last_Java_frame() ) { | |
1787 frame f = last_frame(); | |
1788 tty->print(" (pc: " INTPTR_FORMAT " sp: " INTPTR_FORMAT " )", f.pc(), f.sp()); | |
1789 } | |
1790 tty->print_cr(" of type: %s", instanceKlass::cast(_pending_async_exception->klass())->external_name()); | |
1791 } | |
1792 _pending_async_exception = NULL; | |
1793 clear_has_async_exception(); | |
1794 } | |
1795 } | |
1796 | |
1797 if (check_unsafe_error && | |
1798 condition == _async_unsafe_access_error && !has_pending_exception()) { | |
1799 condition = _no_async_condition; // done | |
1800 switch (thread_state()) { | |
1801 case _thread_in_vm: | |
1802 { | |
1803 JavaThread* THREAD = this; | |
1804 THROW_MSG(vmSymbols::java_lang_InternalError(), "a fault occurred in an unsafe memory access operation"); | |
1805 } | |
1806 case _thread_in_native: | |
1807 { | |
1808 ThreadInVMfromNative tiv(this); | |
1809 JavaThread* THREAD = this; | |
1810 THROW_MSG(vmSymbols::java_lang_InternalError(), "a fault occurred in an unsafe memory access operation"); | |
1811 } | |
1812 case _thread_in_Java: | |
1813 { | |
1814 ThreadInVMfromJava tiv(this); | |
1815 JavaThread* THREAD = this; | |
1816 THROW_MSG(vmSymbols::java_lang_InternalError(), "a fault occurred in a recent unsafe memory access operation in compiled Java code"); | |
1817 } | |
1818 default: | |
1819 ShouldNotReachHere(); | |
1820 } | |
1821 } | |
1822 | |
1823 assert(condition == _no_async_condition || has_pending_exception() || | |
1824 (!check_unsafe_error && condition == _async_unsafe_access_error), | |
1825 "must have handled the async condition, if no exception"); | |
1826 } | |
1827 | |
1828 void JavaThread::handle_special_runtime_exit_condition(bool check_asyncs) { | |
1829 // | |
1830 // Check for pending external suspend. Internal suspend requests do | |
1831 // not use handle_special_runtime_exit_condition(). | |
1832 // If JNIEnv proxies are allowed, don't self-suspend if the target | |
1833 // thread is not the current thread. In older versions of jdbx, jdbx | |
1834 // threads could call into the VM with another thread's JNIEnv so we | |
1835 // can be here operating on behalf of a suspended thread (4432884). | |
1836 bool do_self_suspend = is_external_suspend_with_lock(); | |
1837 if (do_self_suspend && (!AllowJNIEnvProxy || this == JavaThread::current())) { | |
1838 // | |
1839 // Because thread is external suspended the safepoint code will count | |
1840 // thread as at a safepoint. This can be odd because we can be here | |
1841 // as _thread_in_Java which would normally transition to _thread_blocked | |
1842 // at a safepoint. We would like to mark the thread as _thread_blocked | |
1843 // before calling java_suspend_self like all other callers of it but | |
1844 // we must then observe proper safepoint protocol. (We can't leave | |
1845 // _thread_blocked with a safepoint in progress). However we can be | |
1846 // here as _thread_in_native_trans so we can't use a normal transition | |
1847 // constructor/destructor pair because they assert on that type of | |
1848 // transition. We could do something like: | |
1849 // | |
1850 // JavaThreadState state = thread_state(); | |
1851 // set_thread_state(_thread_in_vm); | |
1852 // { | |
1853 // ThreadBlockInVM tbivm(this); | |
1854 // java_suspend_self() | |
1855 // } | |
1856 // set_thread_state(_thread_in_vm_trans); | |
1857 // if (safepoint) block; | |
1858 // set_thread_state(state); | |
1859 // | |
1860 // but that is pretty messy. Instead we just go with the way the | |
1861 // code has worked before and note that this is the only path to | |
1862 // java_suspend_self that doesn't put the thread in _thread_blocked | |
1863 // mode. | |
1864 | |
1865 frame_anchor()->make_walkable(this); | |
1866 java_suspend_self(); | |
1867 | |
1868 // We might be here for reasons in addition to the self-suspend request | |
1869 // so check for other async requests. | |
1870 } | |
1871 | |
1872 if (check_asyncs) { | |
1873 check_and_handle_async_exceptions(); | |
1874 } | |
1875 } | |
1876 | |
1877 void JavaThread::send_thread_stop(oop java_throwable) { | |
1878 assert(Thread::current()->is_VM_thread(), "should be in the vm thread"); | |
1879 assert(Threads_lock->is_locked(), "Threads_lock should be locked by safepoint code"); | |
1880 assert(SafepointSynchronize::is_at_safepoint(), "all threads are stopped"); | |
1881 | |
1882 // Do not throw asynchronous exceptions against the compiler thread | |
1883 // (the compiler thread should not be a Java thread -- fix in 1.4.2) | |
1884 if (is_Compiler_thread()) return; | |
1885 | |
1886 // This is a change from JDK 1.1, but JDK 1.2 will also do it: | |
1142 | 1887 if (java_throwable->is_a(SystemDictionary::ThreadDeath_klass())) { |
0 | 1888 java_lang_Thread::set_stillborn(threadObj()); |
1889 } | |
1890 | |
1891 { | |
1892 // Actually throw the Throwable against the target Thread - however | |
1893 // only if there is no thread death exception installed already. | |
1142 | 1894 if (_pending_async_exception == NULL || !_pending_async_exception->is_a(SystemDictionary::ThreadDeath_klass())) { |
0 | 1895 // If the topmost frame is a runtime stub, then we are calling into |
1896 // OptoRuntime from compiled code. Some runtime stubs (new, monitor_exit..) | |
1897 // must deoptimize the caller before continuing, as the compiled exception handler table | |
1898 // may not be valid | |
1899 if (has_last_Java_frame()) { | |
1900 frame f = last_frame(); | |
1901 if (f.is_runtime_frame() || f.is_safepoint_blob_frame()) { | |
1902 // BiasedLocking needs an updated RegisterMap for the revoke monitors pass | |
1903 RegisterMap reg_map(this, UseBiasedLocking); | |
1904 frame compiled_frame = f.sender(®_map); | |
1905 if (compiled_frame.can_be_deoptimized()) { | |
1906 Deoptimization::deoptimize(this, compiled_frame, ®_map); | |
1907 } | |
1908 } | |
1909 } | |
1910 | |
1911 // Set async. pending exception in thread. | |
1912 set_pending_async_exception(java_throwable); | |
1913 | |
1914 if (TraceExceptions) { | |
1915 ResourceMark rm; | |
1916 tty->print_cr("Pending Async. exception installed of type: %s", instanceKlass::cast(_pending_async_exception->klass())->external_name()); | |
1917 } | |
1918 // for AbortVMOnException flag | |
1919 NOT_PRODUCT(Exceptions::debug_check_abort(instanceKlass::cast(_pending_async_exception->klass())->external_name())); | |
1920 } | |
1921 } | |
1922 | |
1923 | |
1924 // Interrupt thread so it will wake up from a potential wait() | |
1925 Thread::interrupt(this); | |
1926 } | |
1927 | |
1928 // External suspension mechanism. | |
1929 // | |
1930 // Tell the VM to suspend a thread when ever it knows that it does not hold on | |
1931 // to any VM_locks and it is at a transition | |
1932 // Self-suspension will happen on the transition out of the vm. | |
1933 // Catch "this" coming in from JNIEnv pointers when the thread has been freed | |
1934 // | |
1935 // Guarantees on return: | |
1936 // + Target thread will not execute any new bytecode (that's why we need to | |
1937 // force a safepoint) | |
1938 // + Target thread will not enter any new monitors | |
1939 // | |
1940 void JavaThread::java_suspend() { | |
1941 { MutexLocker mu(Threads_lock); | |
1942 if (!Threads::includes(this) || is_exiting() || this->threadObj() == NULL) { | |
1943 return; | |
1944 } | |
1945 } | |
1946 | |
1947 { MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag); | |
1948 if (!is_external_suspend()) { | |
1949 // a racing resume has cancelled us; bail out now | |
1950 return; | |
1951 } | |
1952 | |
1953 // suspend is done | |
1954 uint32_t debug_bits = 0; | |
1955 // Warning: is_ext_suspend_completed() may temporarily drop the | |
1956 // SR_lock to allow the thread to reach a stable thread state if | |
1957 // it is currently in a transient thread state. | |
1958 if (is_ext_suspend_completed(false /* !called_by_wait */, | |
1959 SuspendRetryDelay, &debug_bits) ) { | |
1960 return; | |
1961 } | |
1962 } | |
1963 | |
1964 VM_ForceSafepoint vm_suspend; | |
1965 VMThread::execute(&vm_suspend); | |
1966 } | |
1967 | |
1968 // Part II of external suspension. | |
1969 // A JavaThread self suspends when it detects a pending external suspend | |
1970 // request. This is usually on transitions. It is also done in places | |
1971 // where continuing to the next transition would surprise the caller, | |
1972 // e.g., monitor entry. | |
1973 // | |
1974 // Returns the number of times that the thread self-suspended. | |
1975 // | |
1976 // Note: DO NOT call java_suspend_self() when you just want to block current | |
1977 // thread. java_suspend_self() is the second stage of cooperative | |
1978 // suspension for external suspend requests and should only be used | |
1979 // to complete an external suspend request. | |
1980 // | |
1981 int JavaThread::java_suspend_self() { | |
1982 int ret = 0; | |
1983 | |
1984 // we are in the process of exiting so don't suspend | |
1985 if (is_exiting()) { | |
1986 clear_external_suspend(); | |
1987 return ret; | |
1988 } | |
1989 | |
1990 assert(_anchor.walkable() || | |
1991 (is_Java_thread() && !((JavaThread*)this)->has_last_Java_frame()), | |
1992 "must have walkable stack"); | |
1993 | |
1994 MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag); | |
1995 | |
979 | 1996 assert(!this->is_ext_suspended(), |
0 | 1997 "a thread trying to self-suspend should not already be suspended"); |
1998 | |
1999 if (this->is_suspend_equivalent()) { | |
2000 // If we are self-suspending as a result of the lifting of a | |
2001 // suspend equivalent condition, then the suspend_equivalent | |
2002 // flag is not cleared until we set the ext_suspended flag so | |
2003 // that wait_for_ext_suspend_completion() returns consistent | |
2004 // results. | |
2005 this->clear_suspend_equivalent(); | |
2006 } | |
2007 | |
2008 // A racing resume may have cancelled us before we grabbed SR_lock | |
2009 // above. Or another external suspend request could be waiting for us | |
2010 // by the time we return from SR_lock()->wait(). The thread | |
2011 // that requested the suspension may already be trying to walk our | |
2012 // stack and if we return now, we can change the stack out from under | |
2013 // it. This would be a "bad thing (TM)" and cause the stack walker | |
2014 // to crash. We stay self-suspended until there are no more pending | |
2015 // external suspend requests. | |
2016 while (is_external_suspend()) { | |
2017 ret++; | |
2018 this->set_ext_suspended(); | |
2019 | |
2020 // _ext_suspended flag is cleared by java_resume() | |
2021 while (is_ext_suspended()) { | |
2022 this->SR_lock()->wait(Mutex::_no_safepoint_check_flag); | |
2023 } | |
2024 } | |
2025 | |
2026 return ret; | |
2027 } | |
2028 | |
2029 #ifdef ASSERT | |
2030 // verify the JavaThread has not yet been published in the Threads::list, and | |
2031 // hence doesn't need protection from concurrent access at this stage | |
2032 void JavaThread::verify_not_published() { | |
2033 if (!Threads_lock->owned_by_self()) { | |
2034 MutexLockerEx ml(Threads_lock, Mutex::_no_safepoint_check_flag); | |
2035 assert( !Threads::includes(this), | |
2036 "java thread shouldn't have been published yet!"); | |
2037 } | |
2038 else { | |
2039 assert( !Threads::includes(this), | |
2040 "java thread shouldn't have been published yet!"); | |
2041 } | |
2042 } | |
2043 #endif | |
2044 | |
2045 // Slow path when the native==>VM/Java barriers detect a safepoint is in | |
2046 // progress or when _suspend_flags is non-zero. | |
2047 // Current thread needs to self-suspend if there is a suspend request and/or | |
2048 // block if a safepoint is in progress. | |
2049 // Async exception ISN'T checked. | |
2050 // Note only the ThreadInVMfromNative transition can call this function | |
2051 // directly and when thread state is _thread_in_native_trans | |
2052 void JavaThread::check_safepoint_and_suspend_for_native_trans(JavaThread *thread) { | |
2053 assert(thread->thread_state() == _thread_in_native_trans, "wrong state"); | |
2054 | |
2055 JavaThread *curJT = JavaThread::current(); | |
2056 bool do_self_suspend = thread->is_external_suspend(); | |
2057 | |
2058 assert(!curJT->has_last_Java_frame() || curJT->frame_anchor()->walkable(), "Unwalkable stack in native->vm transition"); | |
2059 | |
2060 // If JNIEnv proxies are allowed, don't self-suspend if the target | |
2061 // thread is not the current thread. In older versions of jdbx, jdbx | |
2062 // threads could call into the VM with another thread's JNIEnv so we | |
2063 // can be here operating on behalf of a suspended thread (4432884). | |
2064 if (do_self_suspend && (!AllowJNIEnvProxy || curJT == thread)) { | |
2065 JavaThreadState state = thread->thread_state(); | |
2066 | |
2067 // We mark this thread_blocked state as a suspend-equivalent so | |
2068 // that a caller to is_ext_suspend_completed() won't be confused. | |
2069 // The suspend-equivalent state is cleared by java_suspend_self(). | |
2070 thread->set_suspend_equivalent(); | |
2071 | |
2072 // If the safepoint code sees the _thread_in_native_trans state, it will | |
2073 // wait until the thread changes to other thread state. There is no | |
2074 // guarantee on how soon we can obtain the SR_lock and complete the | |
2075 // self-suspend request. It would be a bad idea to let safepoint wait for | |
2076 // too long. Temporarily change the state to _thread_blocked to | |
2077 // let the VM thread know that this thread is ready for GC. The problem | |
2078 // of changing thread state is that safepoint could happen just after | |
2079 // java_suspend_self() returns after being resumed, and VM thread will | |
2080 // see the _thread_blocked state. We must check for safepoint | |
2081 // after restoring the state and make sure we won't leave while a safepoint | |
2082 // is in progress. | |
2083 thread->set_thread_state(_thread_blocked); | |
2084 thread->java_suspend_self(); | |
2085 thread->set_thread_state(state); | |
2086 // Make sure new state is seen by VM thread | |
2087 if (os::is_MP()) { | |
2088 if (UseMembar) { | |
2089 // Force a fence between the write above and read below | |
2090 OrderAccess::fence(); | |
2091 } else { | |
2092 // Must use this rather than serialization page in particular on Windows | |
2093 InterfaceSupport::serialize_memory(thread); | |
2094 } | |
2095 } | |
2096 } | |
2097 | |
2098 if (SafepointSynchronize::do_call_back()) { | |
2099 // If we are safepointing, then block the caller which may not be | |
2100 // the same as the target thread (see above). | |
2101 SafepointSynchronize::block(curJT); | |
2102 } | |
2103 | |
2104 if (thread->is_deopt_suspend()) { | |
2105 thread->clear_deopt_suspend(); | |
2106 RegisterMap map(thread, false); | |
2107 frame f = thread->last_frame(); | |
2108 while ( f.id() != thread->must_deopt_id() && ! f.is_first_frame()) { | |
2109 f = f.sender(&map); | |
2110 } | |
2111 if (f.id() == thread->must_deopt_id()) { | |
2112 thread->clear_must_deopt_id(); | |
2113 // Since we know we're safe to deopt the current state is a safe state | |
2114 f.deoptimize(thread, true); | |
2115 } else { | |
2116 fatal("missed deoptimization!"); | |
2117 } | |
2118 } | |
2119 } | |
2120 | |
2121 // Slow path when the native==>VM/Java barriers detect a safepoint is in | |
2122 // progress or when _suspend_flags is non-zero. | |
2123 // Current thread needs to self-suspend if there is a suspend request and/or | |
2124 // block if a safepoint is in progress. | |
2125 // Also check for pending async exception (not including unsafe access error). | |
2126 // Note only the native==>VM/Java barriers can call this function and when | |
2127 // thread state is _thread_in_native_trans. | |
2128 void JavaThread::check_special_condition_for_native_trans(JavaThread *thread) { | |
2129 check_safepoint_and_suspend_for_native_trans(thread); | |
2130 | |
2131 if (thread->has_async_exception()) { | |
2132 // We are in _thread_in_native_trans state, don't handle unsafe | |
2133 // access error since that may block. | |
2134 thread->check_and_handle_async_exceptions(false); | |
2135 } | |
2136 } | |
2137 | |
2138 // We need to guarantee the Threads_lock here, since resumes are not | |
2139 // allowed during safepoint synchronization | |
2140 // Can only resume from an external suspension | |
2141 void JavaThread::java_resume() { | |
2142 assert_locked_or_safepoint(Threads_lock); | |
2143 | |
2144 // Sanity check: thread is gone, has started exiting or the thread | |
2145 // was not externally suspended. | |
2146 if (!Threads::includes(this) || is_exiting() || !is_external_suspend()) { | |
2147 return; | |
2148 } | |
2149 | |
2150 MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag); | |
2151 | |
2152 clear_external_suspend(); | |
2153 | |
2154 if (is_ext_suspended()) { | |
2155 clear_ext_suspended(); | |
2156 SR_lock()->notify_all(); | |
2157 } | |
2158 } | |
2159 | |
2160 void JavaThread::create_stack_guard_pages() { | |
2161 if (! os::uses_stack_guard_pages() || _stack_guard_state != stack_guard_unused) return; | |
2162 address low_addr = stack_base() - stack_size(); | |
2163 size_t len = (StackYellowPages + StackRedPages) * os::vm_page_size(); | |
2164 | |
2165 int allocate = os::allocate_stack_guard_pages(); | |
2166 // warning("Guarding at " PTR_FORMAT " for len " SIZE_FORMAT "\n", low_addr, len); | |
2167 | |
1320
3b3d12e645e7
6929067: Stack guard pages should be removed when thread is detached
coleenp
parents:
1290
diff
changeset
|
2168 if (allocate && !os::create_stack_guard_pages((char *) low_addr, len)) { |
0 | 2169 warning("Attempt to allocate stack guard pages failed."); |
2170 return; | |
2171 } | |
2172 | |
2173 if (os::guard_memory((char *) low_addr, len)) { | |
2174 _stack_guard_state = stack_guard_enabled; | |
2175 } else { | |
2176 warning("Attempt to protect stack guard pages failed."); | |
2177 if (os::uncommit_memory((char *) low_addr, len)) { | |
2178 warning("Attempt to deallocate stack guard pages failed."); | |
2179 } | |
2180 } | |
2181 } | |
2182 | |
2183 void JavaThread::remove_stack_guard_pages() { | |
2184 if (_stack_guard_state == stack_guard_unused) return; | |
2185 address low_addr = stack_base() - stack_size(); | |
2186 size_t len = (StackYellowPages + StackRedPages) * os::vm_page_size(); | |
2187 | |
2188 if (os::allocate_stack_guard_pages()) { | |
1320
3b3d12e645e7
6929067: Stack guard pages should be removed when thread is detached
coleenp
parents:
1290
diff
changeset
|
2189 if (os::remove_stack_guard_pages((char *) low_addr, len)) { |
0 | 2190 _stack_guard_state = stack_guard_unused; |
2191 } else { | |
2192 warning("Attempt to deallocate stack guard pages failed."); | |
2193 } | |
2194 } else { | |
2195 if (_stack_guard_state == stack_guard_unused) return; | |
2196 if (os::unguard_memory((char *) low_addr, len)) { | |
2197 _stack_guard_state = stack_guard_unused; | |
2198 } else { | |
2199 warning("Attempt to unprotect stack guard pages failed."); | |
2200 } | |
2201 } | |
2202 } | |
2203 | |
2204 void JavaThread::enable_stack_yellow_zone() { | |
2205 assert(_stack_guard_state != stack_guard_unused, "must be using guard pages."); | |
2206 assert(_stack_guard_state != stack_guard_enabled, "already enabled"); | |
2207 | |
2208 // The base notation is from the stacks point of view, growing downward. | |
2209 // We need to adjust it to work correctly with guard_memory() | |
2210 address base = stack_yellow_zone_base() - stack_yellow_zone_size(); | |
2211 | |
2212 guarantee(base < stack_base(),"Error calculating stack yellow zone"); | |
2213 guarantee(base < os::current_stack_pointer(),"Error calculating stack yellow zone"); | |
2214 | |
2215 if (os::guard_memory((char *) base, stack_yellow_zone_size())) { | |
2216 _stack_guard_state = stack_guard_enabled; | |
2217 } else { | |
2218 warning("Attempt to guard stack yellow zone failed."); | |
2219 } | |
2220 enable_register_stack_guard(); | |
2221 } | |
2222 | |
2223 void JavaThread::disable_stack_yellow_zone() { | |
2224 assert(_stack_guard_state != stack_guard_unused, "must be using guard pages."); | |
2225 assert(_stack_guard_state != stack_guard_yellow_disabled, "already disabled"); | |
2226 | |
2227 // Simply return if called for a thread that does not use guard pages. | |
2228 if (_stack_guard_state == stack_guard_unused) return; | |
2229 | |
2230 // The base notation is from the stacks point of view, growing downward. | |
2231 // We need to adjust it to work correctly with guard_memory() | |
2232 address base = stack_yellow_zone_base() - stack_yellow_zone_size(); | |
2233 | |
2234 if (os::unguard_memory((char *)base, stack_yellow_zone_size())) { | |
2235 _stack_guard_state = stack_guard_yellow_disabled; | |
2236 } else { | |
2237 warning("Attempt to unguard stack yellow zone failed."); | |
2238 } | |
2239 disable_register_stack_guard(); | |
2240 } | |
2241 | |
2242 void JavaThread::enable_stack_red_zone() { | |
2243 // The base notation is from the stacks point of view, growing downward. | |
2244 // We need to adjust it to work correctly with guard_memory() | |
2245 assert(_stack_guard_state != stack_guard_unused, "must be using guard pages."); | |
2246 address base = stack_red_zone_base() - stack_red_zone_size(); | |
2247 | |
2248 guarantee(base < stack_base(),"Error calculating stack red zone"); | |
2249 guarantee(base < os::current_stack_pointer(),"Error calculating stack red zone"); | |
2250 | |
2251 if(!os::guard_memory((char *) base, stack_red_zone_size())) { | |
2252 warning("Attempt to guard stack red zone failed."); | |
2253 } | |
2254 } | |
2255 | |
2256 void JavaThread::disable_stack_red_zone() { | |
2257 // The base notation is from the stacks point of view, growing downward. | |
2258 // We need to adjust it to work correctly with guard_memory() | |
2259 assert(_stack_guard_state != stack_guard_unused, "must be using guard pages."); | |
2260 address base = stack_red_zone_base() - stack_red_zone_size(); | |
2261 if (!os::unguard_memory((char *)base, stack_red_zone_size())) { | |
2262 warning("Attempt to unguard stack red zone failed."); | |
2263 } | |
2264 } | |
2265 | |
2266 void JavaThread::frames_do(void f(frame*, const RegisterMap* map)) { | |
2267 // ignore is there is no stack | |
2268 if (!has_last_Java_frame()) return; | |
2269 // traverse the stack frames. Starts from top frame. | |
2270 for(StackFrameStream fst(this); !fst.is_done(); fst.next()) { | |
2271 frame* fr = fst.current(); | |
2272 f(fr, fst.register_map()); | |
2273 } | |
2274 } | |
2275 | |
2276 | |
2277 #ifndef PRODUCT | |
2278 // Deoptimization | |
2279 // Function for testing deoptimization | |
2280 void JavaThread::deoptimize() { | |
2281 // BiasedLocking needs an updated RegisterMap for the revoke monitors pass | |
2282 StackFrameStream fst(this, UseBiasedLocking); | |
2283 bool deopt = false; // Dump stack only if a deopt actually happens. | |
2284 bool only_at = strlen(DeoptimizeOnlyAt) > 0; | |
2285 // Iterate over all frames in the thread and deoptimize | |
2286 for(; !fst.is_done(); fst.next()) { | |
2287 if(fst.current()->can_be_deoptimized()) { | |
2288 | |
2289 if (only_at) { | |
2290 // Deoptimize only at particular bcis. DeoptimizeOnlyAt | |
2291 // consists of comma or carriage return separated numbers so | |
2292 // search for the current bci in that string. | |
2293 address pc = fst.current()->pc(); | |
2294 nmethod* nm = (nmethod*) fst.current()->cb(); | |
2295 ScopeDesc* sd = nm->scope_desc_at( pc); | |
2296 char buffer[8]; | |
2297 jio_snprintf(buffer, sizeof(buffer), "%d", sd->bci()); | |
2298 size_t len = strlen(buffer); | |
2299 const char * found = strstr(DeoptimizeOnlyAt, buffer); | |
2300 while (found != NULL) { | |
2301 if ((found[len] == ',' || found[len] == '\n' || found[len] == '\0') && | |
2302 (found == DeoptimizeOnlyAt || found[-1] == ',' || found[-1] == '\n')) { | |
2303 // Check that the bci found is bracketed by terminators. | |
2304 break; | |
2305 } | |
2306 found = strstr(found + 1, buffer); | |
2307 } | |
2308 if (!found) { | |
2309 continue; | |
2310 } | |
2311 } | |
2312 | |
2313 if (DebugDeoptimization && !deopt) { | |
2314 deopt = true; // One-time only print before deopt | |
2315 tty->print_cr("[BEFORE Deoptimization]"); | |
2316 trace_frames(); | |
2317 trace_stack(); | |
2318 } | |
2319 Deoptimization::deoptimize(this, *fst.current(), fst.register_map()); | |
2320 } | |
2321 } | |
2322 | |
2323 if (DebugDeoptimization && deopt) { | |
2324 tty->print_cr("[AFTER Deoptimization]"); | |
2325 trace_frames(); | |
2326 } | |
2327 } | |
2328 | |
2329 | |
2330 // Make zombies | |
2331 void JavaThread::make_zombies() { | |
2332 for(StackFrameStream fst(this); !fst.is_done(); fst.next()) { | |
2333 if (fst.current()->can_be_deoptimized()) { | |
2334 // it is a Java nmethod | |
2335 nmethod* nm = CodeCache::find_nmethod(fst.current()->pc()); | |
2336 nm->make_not_entrant(); | |
2337 } | |
2338 } | |
2339 } | |
2340 #endif // PRODUCT | |
2341 | |
2342 | |
2343 void JavaThread::deoptimized_wrt_marked_nmethods() { | |
2344 if (!has_last_Java_frame()) return; | |
2345 // BiasedLocking needs an updated RegisterMap for the revoke monitors pass | |
2346 StackFrameStream fst(this, UseBiasedLocking); | |
2347 for(; !fst.is_done(); fst.next()) { | |
2348 if (fst.current()->should_be_deoptimized()) { | |
2349 Deoptimization::deoptimize(this, *fst.current(), fst.register_map()); | |
2350 } | |
2351 } | |
2352 } | |
2353 | |
2354 | |
2355 // GC support | |
2356 static void frame_gc_epilogue(frame* f, const RegisterMap* map) { f->gc_epilogue(); } | |
2357 | |
2358 void JavaThread::gc_epilogue() { | |
2359 frames_do(frame_gc_epilogue); | |
2360 } | |
2361 | |
2362 | |
2363 static void frame_gc_prologue(frame* f, const RegisterMap* map) { f->gc_prologue(); } | |
2364 | |
2365 void JavaThread::gc_prologue() { | |
2366 frames_do(frame_gc_prologue); | |
2367 } | |
2368 | |
1119
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2369 // If the caller is a NamedThread, then remember, in the current scope, |
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2370 // the given JavaThread in its _processed_thread field. |
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2371 class RememberProcessedThread: public StackObj { |
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2372 NamedThread* _cur_thr; |
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2373 public: |
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2374 RememberProcessedThread(JavaThread* jthr) { |
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2375 Thread* thread = Thread::current(); |
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2376 if (thread->is_Named_thread()) { |
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2377 _cur_thr = (NamedThread *)thread; |
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2378 _cur_thr->set_processed_thread(jthr); |
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2379 } else { |
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2380 _cur_thr = NULL; |
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2381 } |
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2382 } |
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2383 |
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2384 ~RememberProcessedThread() { |
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2385 if (_cur_thr) { |
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2386 _cur_thr->set_processed_thread(NULL); |
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2387 } |
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2388 } |
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2389 }; |
0 | 2390 |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
2391 void JavaThread::oops_do(OopClosure* f, CodeBlobClosure* cf) { |
1166 | 2392 // Verify that the deferred card marks have been flushed. |
2393 assert(deferred_card_mark().is_empty(), "Should be empty during GC"); | |
1027
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
997
diff
changeset
|
2394 |
0 | 2395 // The ThreadProfiler oops_do is done from FlatProfiler::oops_do |
2396 // since there may be more than one thread using each ThreadProfiler. | |
2397 | |
2398 // Traverse the GCHandles | |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
2399 Thread::oops_do(f, cf); |
0 | 2400 |
2401 assert( (!has_last_Java_frame() && java_call_counter() == 0) || | |
2402 (has_last_Java_frame() && java_call_counter() > 0), "wrong java_sp info!"); | |
2403 | |
2404 if (has_last_Java_frame()) { | |
1119
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2405 // Record JavaThread to GC thread |
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2406 RememberProcessedThread rpt(this); |
0 | 2407 |
2408 // Traverse the privileged stack | |
2409 if (_privileged_stack_top != NULL) { | |
2410 _privileged_stack_top->oops_do(f); | |
2411 } | |
2412 | |
2413 // traverse the registered growable array | |
2414 if (_array_for_gc != NULL) { | |
2415 for (int index = 0; index < _array_for_gc->length(); index++) { | |
2416 f->do_oop(_array_for_gc->adr_at(index)); | |
2417 } | |
2418 } | |
2419 | |
2420 // Traverse the monitor chunks | |
2421 for (MonitorChunk* chunk = monitor_chunks(); chunk != NULL; chunk = chunk->next()) { | |
2422 chunk->oops_do(f); | |
2423 } | |
2424 | |
2425 // Traverse the execution stack | |
2426 for(StackFrameStream fst(this); !fst.is_done(); fst.next()) { | |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
2427 fst.current()->oops_do(f, cf, fst.register_map()); |
0 | 2428 } |
2429 } | |
2430 | |
2431 // callee_target is never live across a gc point so NULL it here should | |
2432 // it still contain a methdOop. | |
2433 | |
2434 set_callee_target(NULL); | |
2435 | |
2436 assert(vframe_array_head() == NULL, "deopt in progress at a safepoint!"); | |
2437 // If we have deferred set_locals there might be oops waiting to be | |
2438 // written | |
2439 GrowableArray<jvmtiDeferredLocalVariableSet*>* list = deferred_locals(); | |
2440 if (list != NULL) { | |
2441 for (int i = 0; i < list->length(); i++) { | |
2442 list->at(i)->oops_do(f); | |
2443 } | |
2444 } | |
2445 | |
2446 // Traverse instance variables at the end since the GC may be moving things | |
2447 // around using this function | |
2448 f->do_oop((oop*) &_threadObj); | |
2449 f->do_oop((oop*) &_vm_result); | |
2450 f->do_oop((oop*) &_vm_result_2); | |
2451 f->do_oop((oop*) &_exception_oop); | |
2452 f->do_oop((oop*) &_pending_async_exception); | |
2453 | |
2454 if (jvmti_thread_state() != NULL) { | |
2455 jvmti_thread_state()->oops_do(f); | |
2456 } | |
2457 } | |
2458 | |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
2459 void JavaThread::nmethods_do(CodeBlobClosure* cf) { |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
2460 Thread::nmethods_do(cf); // (super method is a no-op) |
0 | 2461 |
2462 assert( (!has_last_Java_frame() && java_call_counter() == 0) || | |
2463 (has_last_Java_frame() && java_call_counter() > 0), "wrong java_sp info!"); | |
2464 | |
2465 if (has_last_Java_frame()) { | |
2466 // Traverse the execution stack | |
2467 for(StackFrameStream fst(this); !fst.is_done(); fst.next()) { | |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
2468 fst.current()->nmethods_do(cf); |
0 | 2469 } |
2470 } | |
2471 } | |
2472 | |
2473 // Printing | |
2474 const char* _get_thread_state_name(JavaThreadState _thread_state) { | |
2475 switch (_thread_state) { | |
2476 case _thread_uninitialized: return "_thread_uninitialized"; | |
2477 case _thread_new: return "_thread_new"; | |
2478 case _thread_new_trans: return "_thread_new_trans"; | |
2479 case _thread_in_native: return "_thread_in_native"; | |
2480 case _thread_in_native_trans: return "_thread_in_native_trans"; | |
2481 case _thread_in_vm: return "_thread_in_vm"; | |
2482 case _thread_in_vm_trans: return "_thread_in_vm_trans"; | |
2483 case _thread_in_Java: return "_thread_in_Java"; | |
2484 case _thread_in_Java_trans: return "_thread_in_Java_trans"; | |
2485 case _thread_blocked: return "_thread_blocked"; | |
2486 case _thread_blocked_trans: return "_thread_blocked_trans"; | |
2487 default: return "unknown thread state"; | |
2488 } | |
2489 } | |
2490 | |
2491 #ifndef PRODUCT | |
2492 void JavaThread::print_thread_state_on(outputStream *st) const { | |
2493 st->print_cr(" JavaThread state: %s", _get_thread_state_name(_thread_state)); | |
2494 }; | |
2495 void JavaThread::print_thread_state() const { | |
2496 print_thread_state_on(tty); | |
2497 }; | |
2498 #endif // PRODUCT | |
2499 | |
2500 // Called by Threads::print() for VM_PrintThreads operation | |
2501 void JavaThread::print_on(outputStream *st) const { | |
2502 st->print("\"%s\" ", get_thread_name()); | |
2503 oop thread_oop = threadObj(); | |
2504 if (thread_oop != NULL && java_lang_Thread::is_daemon(thread_oop)) st->print("daemon "); | |
2505 Thread::print_on(st); | |
2506 // print guess for valid stack memory region (assume 4K pages); helps lock debugging | |
702
b9fba36710f2
6699669: Hotspot server leaves synchronized block with monitor in bad state
xlu
parents:
669
diff
changeset
|
2507 st->print_cr("[" INTPTR_FORMAT "]", (intptr_t)last_Java_sp() & ~right_n_bits(12)); |
0 | 2508 if (thread_oop != NULL && JDK_Version::is_gte_jdk15x_version()) { |
2509 st->print_cr(" java.lang.Thread.State: %s", java_lang_Thread::thread_status_name(thread_oop)); | |
2510 } | |
2511 #ifndef PRODUCT | |
2512 print_thread_state_on(st); | |
2513 _safepoint_state->print_on(st); | |
2514 #endif // PRODUCT | |
2515 } | |
2516 | |
2517 // Called by fatal error handler. The difference between this and | |
2518 // JavaThread::print() is that we can't grab lock or allocate memory. | |
2519 void JavaThread::print_on_error(outputStream* st, char *buf, int buflen) const { | |
2520 st->print("JavaThread \"%s\"", get_thread_name_string(buf, buflen)); | |
2521 oop thread_obj = threadObj(); | |
2522 if (thread_obj != NULL) { | |
2523 if (java_lang_Thread::is_daemon(thread_obj)) st->print(" daemon"); | |
2524 } | |
2525 st->print(" ["); | |
2526 st->print("%s", _get_thread_state_name(_thread_state)); | |
2527 if (osthread()) { | |
2528 st->print(", id=%d", osthread()->thread_id()); | |
2529 } | |
2530 st->print(", stack(" PTR_FORMAT "," PTR_FORMAT ")", | |
2531 _stack_base - _stack_size, _stack_base); | |
2532 st->print("]"); | |
2533 return; | |
2534 } | |
2535 | |
2536 // Verification | |
2537 | |
2538 static void frame_verify(frame* f, const RegisterMap *map) { f->verify(map); } | |
2539 | |
2540 void JavaThread::verify() { | |
2541 // Verify oops in the thread. | |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
2542 oops_do(&VerifyOopClosure::verify_oop, NULL); |
0 | 2543 |
2544 // Verify the stack frames. | |
2545 frames_do(frame_verify); | |
2546 } | |
2547 | |
2548 // CR 6300358 (sub-CR 2137150) | |
2549 // Most callers of this method assume that it can't return NULL but a | |
2550 // thread may not have a name whilst it is in the process of attaching to | |
2551 // the VM - see CR 6412693, and there are places where a JavaThread can be | |
2552 // seen prior to having it's threadObj set (eg JNI attaching threads and | |
2553 // if vm exit occurs during initialization). These cases can all be accounted | |
2554 // for such that this method never returns NULL. | |
2555 const char* JavaThread::get_thread_name() const { | |
2556 #ifdef ASSERT | |
2557 // early safepoints can hit while current thread does not yet have TLS | |
2558 if (!SafepointSynchronize::is_at_safepoint()) { | |
2559 Thread *cur = Thread::current(); | |
2560 if (!(cur->is_Java_thread() && cur == this)) { | |
2561 // Current JavaThreads are allowed to get their own name without | |
2562 // the Threads_lock. | |
2563 assert_locked_or_safepoint(Threads_lock); | |
2564 } | |
2565 } | |
2566 #endif // ASSERT | |
2567 return get_thread_name_string(); | |
2568 } | |
2569 | |
2570 // Returns a non-NULL representation of this thread's name, or a suitable | |
2571 // descriptive string if there is no set name | |
2572 const char* JavaThread::get_thread_name_string(char* buf, int buflen) const { | |
2573 const char* name_str; | |
2574 oop thread_obj = threadObj(); | |
2575 if (thread_obj != NULL) { | |
2576 typeArrayOop name = java_lang_Thread::name(thread_obj); | |
2577 if (name != NULL) { | |
2578 if (buf == NULL) { | |
2579 name_str = UNICODE::as_utf8((jchar*) name->base(T_CHAR), name->length()); | |
2580 } | |
2581 else { | |
2582 name_str = UNICODE::as_utf8((jchar*) name->base(T_CHAR), name->length(), buf, buflen); | |
2583 } | |
2584 } | |
2585 else if (is_attaching()) { // workaround for 6412693 - see 6404306 | |
2586 name_str = "<no-name - thread is attaching>"; | |
2587 } | |
2588 else { | |
2589 name_str = Thread::name(); | |
2590 } | |
2591 } | |
2592 else { | |
2593 name_str = Thread::name(); | |
2594 } | |
2595 assert(name_str != NULL, "unexpected NULL thread name"); | |
2596 return name_str; | |
2597 } | |
2598 | |
2599 | |
2600 const char* JavaThread::get_threadgroup_name() const { | |
2601 debug_only(if (JavaThread::current() != this) assert_locked_or_safepoint(Threads_lock);) | |
2602 oop thread_obj = threadObj(); | |
2603 if (thread_obj != NULL) { | |
2604 oop thread_group = java_lang_Thread::threadGroup(thread_obj); | |
2605 if (thread_group != NULL) { | |
2606 typeArrayOop name = java_lang_ThreadGroup::name(thread_group); | |
2607 // ThreadGroup.name can be null | |
2608 if (name != NULL) { | |
2609 const char* str = UNICODE::as_utf8((jchar*) name->base(T_CHAR), name->length()); | |
2610 return str; | |
2611 } | |
2612 } | |
2613 } | |
2614 return NULL; | |
2615 } | |
2616 | |
2617 const char* JavaThread::get_parent_name() const { | |
2618 debug_only(if (JavaThread::current() != this) assert_locked_or_safepoint(Threads_lock);) | |
2619 oop thread_obj = threadObj(); | |
2620 if (thread_obj != NULL) { | |
2621 oop thread_group = java_lang_Thread::threadGroup(thread_obj); | |
2622 if (thread_group != NULL) { | |
2623 oop parent = java_lang_ThreadGroup::parent(thread_group); | |
2624 if (parent != NULL) { | |
2625 typeArrayOop name = java_lang_ThreadGroup::name(parent); | |
2626 // ThreadGroup.name can be null | |
2627 if (name != NULL) { | |
2628 const char* str = UNICODE::as_utf8((jchar*) name->base(T_CHAR), name->length()); | |
2629 return str; | |
2630 } | |
2631 } | |
2632 } | |
2633 } | |
2634 return NULL; | |
2635 } | |
2636 | |
2637 ThreadPriority JavaThread::java_priority() const { | |
2638 oop thr_oop = threadObj(); | |
2639 if (thr_oop == NULL) return NormPriority; // Bootstrapping | |
2640 ThreadPriority priority = java_lang_Thread::priority(thr_oop); | |
2641 assert(MinPriority <= priority && priority <= MaxPriority, "sanity check"); | |
2642 return priority; | |
2643 } | |
2644 | |
2645 void JavaThread::prepare(jobject jni_thread, ThreadPriority prio) { | |
2646 | |
2647 assert(Threads_lock->owner() == Thread::current(), "must have threads lock"); | |
2648 // Link Java Thread object <-> C++ Thread | |
2649 | |
2650 // Get the C++ thread object (an oop) from the JNI handle (a jthread) | |
2651 // and put it into a new Handle. The Handle "thread_oop" can then | |
2652 // be used to pass the C++ thread object to other methods. | |
2653 | |
2654 // Set the Java level thread object (jthread) field of the | |
2655 // new thread (a JavaThread *) to C++ thread object using the | |
2656 // "thread_oop" handle. | |
2657 | |
2658 // Set the thread field (a JavaThread *) of the | |
2659 // oop representing the java_lang_Thread to the new thread (a JavaThread *). | |
2660 | |
2661 Handle thread_oop(Thread::current(), | |
2662 JNIHandles::resolve_non_null(jni_thread)); | |
2663 assert(instanceKlass::cast(thread_oop->klass())->is_linked(), | |
2664 "must be initialized"); | |
2665 set_threadObj(thread_oop()); | |
2666 java_lang_Thread::set_thread(thread_oop(), this); | |
2667 | |
2668 if (prio == NoPriority) { | |
2669 prio = java_lang_Thread::priority(thread_oop()); | |
2670 assert(prio != NoPriority, "A valid priority should be present"); | |
2671 } | |
2672 | |
2673 // Push the Java priority down to the native thread; needs Threads_lock | |
2674 Thread::set_priority(this, prio); | |
2675 | |
2676 // Add the new thread to the Threads list and set it in motion. | |
2677 // We must have threads lock in order to call Threads::add. | |
2678 // It is crucial that we do not block before the thread is | |
2679 // added to the Threads list for if a GC happens, then the java_thread oop | |
2680 // will not be visited by GC. | |
2681 Threads::add(this); | |
2682 } | |
2683 | |
2684 oop JavaThread::current_park_blocker() { | |
2685 // Support for JSR-166 locks | |
2686 oop thread_oop = threadObj(); | |
242 | 2687 if (thread_oop != NULL && |
2688 JDK_Version::current().supports_thread_park_blocker()) { | |
0 | 2689 return java_lang_Thread::park_blocker(thread_oop); |
2690 } | |
2691 return NULL; | |
2692 } | |
2693 | |
2694 | |
2695 void JavaThread::print_stack_on(outputStream* st) { | |
2696 if (!has_last_Java_frame()) return; | |
2697 ResourceMark rm; | |
2698 HandleMark hm; | |
2699 | |
2700 RegisterMap reg_map(this); | |
2701 vframe* start_vf = last_java_vframe(®_map); | |
2702 int count = 0; | |
2703 for (vframe* f = start_vf; f; f = f->sender() ) { | |
2704 if (f->is_java_frame()) { | |
2705 javaVFrame* jvf = javaVFrame::cast(f); | |
2706 java_lang_Throwable::print_stack_element(st, jvf->method(), jvf->bci()); | |
2707 | |
2708 // Print out lock information | |
2709 if (JavaMonitorsInStackTrace) { | |
2710 jvf->print_lock_info_on(st, count); | |
2711 } | |
2712 } else { | |
2713 // Ignore non-Java frames | |
2714 } | |
2715 | |
2716 // Bail-out case for too deep stacks | |
2717 count++; | |
2718 if (MaxJavaStackTraceDepth == count) return; | |
2719 } | |
2720 } | |
2721 | |
2722 | |
2723 // JVMTI PopFrame support | |
2724 void JavaThread::popframe_preserve_args(ByteSize size_in_bytes, void* start) { | |
2725 assert(_popframe_preserved_args == NULL, "should not wipe out old PopFrame preserved arguments"); | |
2726 if (in_bytes(size_in_bytes) != 0) { | |
2727 _popframe_preserved_args = NEW_C_HEAP_ARRAY(char, in_bytes(size_in_bytes)); | |
2728 _popframe_preserved_args_size = in_bytes(size_in_bytes); | |
1603
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1584
diff
changeset
|
2729 Copy::conjoint_jbytes(start, _popframe_preserved_args, _popframe_preserved_args_size); |
0 | 2730 } |
2731 } | |
2732 | |
2733 void* JavaThread::popframe_preserved_args() { | |
2734 return _popframe_preserved_args; | |
2735 } | |
2736 | |
2737 ByteSize JavaThread::popframe_preserved_args_size() { | |
2738 return in_ByteSize(_popframe_preserved_args_size); | |
2739 } | |
2740 | |
2741 WordSize JavaThread::popframe_preserved_args_size_in_words() { | |
2742 int sz = in_bytes(popframe_preserved_args_size()); | |
2743 assert(sz % wordSize == 0, "argument size must be multiple of wordSize"); | |
2744 return in_WordSize(sz / wordSize); | |
2745 } | |
2746 | |
2747 void JavaThread::popframe_free_preserved_args() { | |
2748 assert(_popframe_preserved_args != NULL, "should not free PopFrame preserved arguments twice"); | |
2749 FREE_C_HEAP_ARRAY(char, (char*) _popframe_preserved_args); | |
2750 _popframe_preserved_args = NULL; | |
2751 _popframe_preserved_args_size = 0; | |
2752 } | |
2753 | |
2754 #ifndef PRODUCT | |
2755 | |
2756 void JavaThread::trace_frames() { | |
2757 tty->print_cr("[Describe stack]"); | |
2758 int frame_no = 1; | |
2759 for(StackFrameStream fst(this); !fst.is_done(); fst.next()) { | |
2760 tty->print(" %d. ", frame_no++); | |
2761 fst.current()->print_value_on(tty,this); | |
2762 tty->cr(); | |
2763 } | |
2764 } | |
2765 | |
2766 | |
2767 void JavaThread::trace_stack_from(vframe* start_vf) { | |
2768 ResourceMark rm; | |
2769 int vframe_no = 1; | |
2770 for (vframe* f = start_vf; f; f = f->sender() ) { | |
2771 if (f->is_java_frame()) { | |
2772 javaVFrame::cast(f)->print_activation(vframe_no++); | |
2773 } else { | |
2774 f->print(); | |
2775 } | |
2776 if (vframe_no > StackPrintLimit) { | |
2777 tty->print_cr("...<more frames>..."); | |
2778 return; | |
2779 } | |
2780 } | |
2781 } | |
2782 | |
2783 | |
2784 void JavaThread::trace_stack() { | |
2785 if (!has_last_Java_frame()) return; | |
2786 ResourceMark rm; | |
2787 HandleMark hm; | |
2788 RegisterMap reg_map(this); | |
2789 trace_stack_from(last_java_vframe(®_map)); | |
2790 } | |
2791 | |
2792 | |
2793 #endif // PRODUCT | |
2794 | |
2795 | |
2796 javaVFrame* JavaThread::last_java_vframe(RegisterMap *reg_map) { | |
2797 assert(reg_map != NULL, "a map must be given"); | |
2798 frame f = last_frame(); | |
2799 for (vframe* vf = vframe::new_vframe(&f, reg_map, this); vf; vf = vf->sender() ) { | |
2800 if (vf->is_java_frame()) return javaVFrame::cast(vf); | |
2801 } | |
2802 return NULL; | |
2803 } | |
2804 | |
2805 | |
2806 klassOop JavaThread::security_get_caller_class(int depth) { | |
2807 vframeStream vfst(this); | |
2808 vfst.security_get_caller_frame(depth); | |
2809 if (!vfst.at_end()) { | |
2810 return vfst.method()->method_holder(); | |
2811 } | |
2812 return NULL; | |
2813 } | |
2814 | |
2815 static void compiler_thread_entry(JavaThread* thread, TRAPS) { | |
2816 assert(thread->is_Compiler_thread(), "must be compiler thread"); | |
2817 CompileBroker::compiler_thread_loop(); | |
2818 } | |
2819 | |
2820 // Create a CompilerThread | |
2821 CompilerThread::CompilerThread(CompileQueue* queue, CompilerCounters* counters) | |
2822 : JavaThread(&compiler_thread_entry) { | |
2823 _env = NULL; | |
2824 _log = NULL; | |
2825 _task = NULL; | |
2826 _queue = queue; | |
2827 _counters = counters; | |
1584 | 2828 _buffer_blob = NULL; |
0 | 2829 |
2830 #ifndef PRODUCT | |
2831 _ideal_graph_printer = NULL; | |
2832 #endif | |
2833 } | |
2834 | |
2835 | |
2836 // ======= Threads ======== | |
2837 | |
2838 // The Threads class links together all active threads, and provides | |
2839 // operations over all threads. It is protected by its own Mutex | |
2840 // lock, which is also used in other contexts to protect thread | |
2841 // operations from having the thread being operated on from exiting | |
2842 // and going away unexpectedly (e.g., safepoint synchronization) | |
2843 | |
2844 JavaThread* Threads::_thread_list = NULL; | |
2845 int Threads::_number_of_threads = 0; | |
2846 int Threads::_number_of_non_daemon_threads = 0; | |
2847 int Threads::_return_code = 0; | |
2848 size_t JavaThread::_stack_size_at_create = 0; | |
2849 | |
2850 // All JavaThreads | |
2851 #define ALL_JAVA_THREADS(X) for (JavaThread* X = _thread_list; X; X = X->next()) | |
2852 | |
2853 void os_stream(); | |
2854 | |
2855 // All JavaThreads + all non-JavaThreads (i.e., every thread in the system) | |
2856 void Threads::threads_do(ThreadClosure* tc) { | |
2857 assert_locked_or_safepoint(Threads_lock); | |
2858 // ALL_JAVA_THREADS iterates through all JavaThreads | |
2859 ALL_JAVA_THREADS(p) { | |
2860 tc->do_thread(p); | |
2861 } | |
2862 // Someday we could have a table or list of all non-JavaThreads. | |
2863 // For now, just manually iterate through them. | |
2864 tc->do_thread(VMThread::vm_thread()); | |
2865 Universe::heap()->gc_threads_do(tc); | |
323
b33eef719520
6740526: sun/management/HotspotThreadMBean/GetInternalThreads.java test failed
xlu
parents:
286
diff
changeset
|
2866 WatcherThread *wt = WatcherThread::watcher_thread(); |
b33eef719520
6740526: sun/management/HotspotThreadMBean/GetInternalThreads.java test failed
xlu
parents:
286
diff
changeset
|
2867 // Strictly speaking, the following NULL check isn't sufficient to make sure |
b33eef719520
6740526: sun/management/HotspotThreadMBean/GetInternalThreads.java test failed
xlu
parents:
286
diff
changeset
|
2868 // the data for WatcherThread is still valid upon being examined. However, |
b33eef719520
6740526: sun/management/HotspotThreadMBean/GetInternalThreads.java test failed
xlu
parents:
286
diff
changeset
|
2869 // considering that WatchThread terminates when the VM is on the way to |
b33eef719520
6740526: sun/management/HotspotThreadMBean/GetInternalThreads.java test failed
xlu
parents:
286
diff
changeset
|
2870 // exit at safepoint, the chance of the above is extremely small. The right |
b33eef719520
6740526: sun/management/HotspotThreadMBean/GetInternalThreads.java test failed
xlu
parents:
286
diff
changeset
|
2871 // way to prevent termination of WatcherThread would be to acquire |
b33eef719520
6740526: sun/management/HotspotThreadMBean/GetInternalThreads.java test failed
xlu
parents:
286
diff
changeset
|
2872 // Terminator_lock, but we can't do that without violating the lock rank |
b33eef719520
6740526: sun/management/HotspotThreadMBean/GetInternalThreads.java test failed
xlu
parents:
286
diff
changeset
|
2873 // checking in some cases. |
b33eef719520
6740526: sun/management/HotspotThreadMBean/GetInternalThreads.java test failed
xlu
parents:
286
diff
changeset
|
2874 if (wt != NULL) |
b33eef719520
6740526: sun/management/HotspotThreadMBean/GetInternalThreads.java test failed
xlu
parents:
286
diff
changeset
|
2875 tc->do_thread(wt); |
b33eef719520
6740526: sun/management/HotspotThreadMBean/GetInternalThreads.java test failed
xlu
parents:
286
diff
changeset
|
2876 |
0 | 2877 // If CompilerThreads ever become non-JavaThreads, add them here |
2878 } | |
2879 | |
2880 jint Threads::create_vm(JavaVMInitArgs* args, bool* canTryAgain) { | |
2881 | |
242 | 2882 extern void JDK_Version_init(); |
2883 | |
0 | 2884 // Check version |
2885 if (!is_supported_jni_version(args->version)) return JNI_EVERSION; | |
2886 | |
2887 // Initialize the output stream module | |
2888 ostream_init(); | |
2889 | |
2890 // Process java launcher properties. | |
2891 Arguments::process_sun_java_launcher_properties(args); | |
2892 | |
2893 // Initialize the os module before using TLS | |
2894 os::init(); | |
2895 | |
2896 // Initialize system properties. | |
2897 Arguments::init_system_properties(); | |
2898 | |
242 | 2899 // So that JDK version can be used as a discrimintor when parsing arguments |
2900 JDK_Version_init(); | |
2901 | |
0 | 2902 // Parse arguments |
2903 jint parse_result = Arguments::parse(args); | |
2904 if (parse_result != JNI_OK) return parse_result; | |
2905 | |
2906 if (PauseAtStartup) { | |
2907 os::pause(); | |
2908 } | |
2909 | |
2910 HS_DTRACE_PROBE(hotspot, vm__init__begin); | |
2911 | |
2912 // Record VM creation timing statistics | |
2913 TraceVmCreationTime create_vm_timer; | |
2914 create_vm_timer.start(); | |
2915 | |
2916 // Timing (must come after argument parsing) | |
2917 TraceTime timer("Create VM", TraceStartupTime); | |
2918 | |
2919 // Initialize the os module after parsing the args | |
2920 jint os_init_2_result = os::init_2(); | |
2921 if (os_init_2_result != JNI_OK) return os_init_2_result; | |
2922 | |
2923 // Initialize output stream logging | |
2924 ostream_init_log(); | |
2925 | |
2926 // Convert -Xrun to -agentlib: if there is no JVM_OnLoad | |
2927 // Must be before create_vm_init_agents() | |
2928 if (Arguments::init_libraries_at_startup()) { | |
2929 convert_vm_init_libraries_to_agents(); | |
2930 } | |
2931 | |
2932 // Launch -agentlib/-agentpath and converted -Xrun agents | |
2933 if (Arguments::init_agents_at_startup()) { | |
2934 create_vm_init_agents(); | |
2935 } | |
2936 | |
2937 // Initialize Threads state | |
2938 _thread_list = NULL; | |
2939 _number_of_threads = 0; | |
2940 _number_of_non_daemon_threads = 0; | |
2941 | |
2942 // Initialize TLS | |
2943 ThreadLocalStorage::init(); | |
2944 | |
2945 // Initialize global data structures and create system classes in heap | |
2946 vm_init_globals(); | |
2947 | |
2948 // Attach the main thread to this os thread | |
2949 JavaThread* main_thread = new JavaThread(); | |
2950 main_thread->set_thread_state(_thread_in_vm); | |
2951 // must do this before set_active_handles and initialize_thread_local_storage | |
2952 // Note: on solaris initialize_thread_local_storage() will (indirectly) | |
2953 // change the stack size recorded here to one based on the java thread | |
2954 // stacksize. This adjusted size is what is used to figure the placement | |
2955 // of the guard pages. | |
2956 main_thread->record_stack_base_and_size(); | |
2957 main_thread->initialize_thread_local_storage(); | |
2958 | |
2959 main_thread->set_active_handles(JNIHandleBlock::allocate_block()); | |
2960 | |
2961 if (!main_thread->set_as_starting_thread()) { | |
2962 vm_shutdown_during_initialization( | |
2963 "Failed necessary internal allocation. Out of swap space"); | |
2964 delete main_thread; | |
2965 *canTryAgain = false; // don't let caller call JNI_CreateJavaVM again | |
2966 return JNI_ENOMEM; | |
2967 } | |
2968 | |
2969 // Enable guard page *after* os::create_main_thread(), otherwise it would | |
2970 // crash Linux VM, see notes in os_linux.cpp. | |
2971 main_thread->create_stack_guard_pages(); | |
2972 | |
2973 // Initialize Java-Leve synchronization subsystem | |
2974 ObjectSynchronizer::Initialize() ; | |
2975 | |
2976 // Initialize global modules | |
2977 jint status = init_globals(); | |
2978 if (status != JNI_OK) { | |
2979 delete main_thread; | |
2980 *canTryAgain = false; // don't let caller call JNI_CreateJavaVM again | |
2981 return status; | |
2982 } | |
2983 | |
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
2984 // Should be done after the heap is fully created |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
2985 main_thread->cache_global_variables(); |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
2986 |
0 | 2987 HandleMark hm; |
2988 | |
2989 { MutexLocker mu(Threads_lock); | |
2990 Threads::add(main_thread); | |
2991 } | |
2992 | |
2993 // Any JVMTI raw monitors entered in onload will transition into | |
2994 // real raw monitor. VM is setup enough here for raw monitor enter. | |
2995 JvmtiExport::transition_pending_onload_raw_monitors(); | |
2996 | |
2997 if (VerifyBeforeGC && | |
2998 Universe::heap()->total_collections() >= VerifyGCStartAt) { | |
2999 Universe::heap()->prepare_for_verify(); | |
3000 Universe::verify(); // make sure we're starting with a clean slate | |
3001 } | |
3002 | |
3003 // Create the VMThread | |
3004 { TraceTime timer("Start VMThread", TraceStartupTime); | |
3005 VMThread::create(); | |
3006 Thread* vmthread = VMThread::vm_thread(); | |
3007 | |
3008 if (!os::create_thread(vmthread, os::vm_thread)) | |
3009 vm_exit_during_initialization("Cannot create VM thread. Out of system resources."); | |
3010 | |
3011 // Wait for the VM thread to become ready, and VMThread::run to initialize | |
3012 // Monitors can have spurious returns, must always check another state flag | |
3013 { | |
3014 MutexLocker ml(Notify_lock); | |
3015 os::start_thread(vmthread); | |
3016 while (vmthread->active_handles() == NULL) { | |
3017 Notify_lock->wait(); | |
3018 } | |
3019 } | |
3020 } | |
3021 | |
3022 assert (Universe::is_fully_initialized(), "not initialized"); | |
3023 EXCEPTION_MARK; | |
3024 | |
3025 // At this point, the Universe is initialized, but we have not executed | |
3026 // any byte code. Now is a good time (the only time) to dump out the | |
3027 // internal state of the JVM for sharing. | |
3028 | |
3029 if (DumpSharedSpaces) { | |
3030 Universe::heap()->preload_and_dump(CHECK_0); | |
3031 ShouldNotReachHere(); | |
3032 } | |
3033 | |
3034 // Always call even when there are not JVMTI environments yet, since environments | |
3035 // may be attached late and JVMTI must track phases of VM execution | |
3036 JvmtiExport::enter_start_phase(); | |
3037 | |
3038 // Notify JVMTI agents that VM has started (JNI is up) - nop if no agents. | |
3039 JvmtiExport::post_vm_start(); | |
3040 | |
3041 { | |
3042 TraceTime timer("Initialize java.lang classes", TraceStartupTime); | |
3043 | |
3044 if (EagerXrunInit && Arguments::init_libraries_at_startup()) { | |
3045 create_vm_init_libraries(); | |
3046 } | |
3047 | |
3048 if (InitializeJavaLangString) { | |
3049 initialize_class(vmSymbolHandles::java_lang_String(), CHECK_0); | |
3050 } else { | |
3051 warning("java.lang.String not initialized"); | |
3052 } | |
3053 | |
18
c7d713375c94
6621621: HashMap front cache should be enabled only with AggressiveOpts
phh
parents:
0
diff
changeset
|
3054 if (AggressiveOpts) { |
192
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3055 { |
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3056 // Forcibly initialize java/util/HashMap and mutate the private |
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3057 // static final "frontCacheEnabled" field before we start creating instances |
18
c7d713375c94
6621621: HashMap front cache should be enabled only with AggressiveOpts
phh
parents:
0
diff
changeset
|
3058 #ifdef ASSERT |
192
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3059 klassOop tmp_k = SystemDictionary::find(vmSymbolHandles::java_util_HashMap(), Handle(), Handle(), CHECK_0); |
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3060 assert(tmp_k == NULL, "java/util/HashMap should not be loaded yet"); |
18
c7d713375c94
6621621: HashMap front cache should be enabled only with AggressiveOpts
phh
parents:
0
diff
changeset
|
3061 #endif |
192
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3062 klassOop k_o = SystemDictionary::resolve_or_null(vmSymbolHandles::java_util_HashMap(), Handle(), Handle(), CHECK_0); |
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3063 KlassHandle k = KlassHandle(THREAD, k_o); |
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3064 guarantee(k.not_null(), "Must find java/util/HashMap"); |
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3065 instanceKlassHandle ik = instanceKlassHandle(THREAD, k()); |
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3066 ik->initialize(CHECK_0); |
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3067 fieldDescriptor fd; |
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3068 // Possible we might not find this field; if so, don't break |
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3069 if (ik->find_local_field(vmSymbols::frontCacheEnabled_name(), vmSymbols::bool_signature(), &fd)) { |
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3070 k()->bool_field_put(fd.offset(), true); |
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3071 } |
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3072 } |
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3073 |
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3074 if (UseStringCache) { |
669
eca19a8425b5
6810653: Change String cache class used by Hotspot from String to StringValue
phh
parents:
441
diff
changeset
|
3075 // Forcibly initialize java/lang/StringValue and mutate the private |
192
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3076 // static final "stringCacheEnabled" field before we start creating instances |
669
eca19a8425b5
6810653: Change String cache class used by Hotspot from String to StringValue
phh
parents:
441
diff
changeset
|
3077 klassOop k_o = SystemDictionary::resolve_or_null(vmSymbolHandles::java_lang_StringValue(), Handle(), Handle(), CHECK_0); |
eca19a8425b5
6810653: Change String cache class used by Hotspot from String to StringValue
phh
parents:
441
diff
changeset
|
3078 // Possible that StringValue isn't present: if so, silently don't break |
eca19a8425b5
6810653: Change String cache class used by Hotspot from String to StringValue
phh
parents:
441
diff
changeset
|
3079 if (k_o != NULL) { |
eca19a8425b5
6810653: Change String cache class used by Hotspot from String to StringValue
phh
parents:
441
diff
changeset
|
3080 KlassHandle k = KlassHandle(THREAD, k_o); |
eca19a8425b5
6810653: Change String cache class used by Hotspot from String to StringValue
phh
parents:
441
diff
changeset
|
3081 instanceKlassHandle ik = instanceKlassHandle(THREAD, k()); |
eca19a8425b5
6810653: Change String cache class used by Hotspot from String to StringValue
phh
parents:
441
diff
changeset
|
3082 ik->initialize(CHECK_0); |
eca19a8425b5
6810653: Change String cache class used by Hotspot from String to StringValue
phh
parents:
441
diff
changeset
|
3083 fieldDescriptor fd; |
eca19a8425b5
6810653: Change String cache class used by Hotspot from String to StringValue
phh
parents:
441
diff
changeset
|
3084 // Possible we might not find this field: if so, silently don't break |
eca19a8425b5
6810653: Change String cache class used by Hotspot from String to StringValue
phh
parents:
441
diff
changeset
|
3085 if (ik->find_local_field(vmSymbols::stringCacheEnabled_name(), vmSymbols::bool_signature(), &fd)) { |
eca19a8425b5
6810653: Change String cache class used by Hotspot from String to StringValue
phh
parents:
441
diff
changeset
|
3086 k()->bool_field_put(fd.offset(), true); |
eca19a8425b5
6810653: Change String cache class used by Hotspot from String to StringValue
phh
parents:
441
diff
changeset
|
3087 } |
192
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3088 } |
18
c7d713375c94
6621621: HashMap front cache should be enabled only with AggressiveOpts
phh
parents:
0
diff
changeset
|
3089 } |
c7d713375c94
6621621: HashMap front cache should be enabled only with AggressiveOpts
phh
parents:
0
diff
changeset
|
3090 } |
c7d713375c94
6621621: HashMap front cache should be enabled only with AggressiveOpts
phh
parents:
0
diff
changeset
|
3091 |
0 | 3092 // Initialize java_lang.System (needed before creating the thread) |
3093 if (InitializeJavaLangSystem) { | |
3094 initialize_class(vmSymbolHandles::java_lang_System(), CHECK_0); | |
3095 initialize_class(vmSymbolHandles::java_lang_ThreadGroup(), CHECK_0); | |
3096 Handle thread_group = create_initial_thread_group(CHECK_0); | |
3097 Universe::set_main_thread_group(thread_group()); | |
3098 initialize_class(vmSymbolHandles::java_lang_Thread(), CHECK_0); | |
3099 oop thread_object = create_initial_thread(thread_group, main_thread, CHECK_0); | |
3100 main_thread->set_threadObj(thread_object); | |
3101 // Set thread status to running since main thread has | |
3102 // been started and running. | |
3103 java_lang_Thread::set_thread_status(thread_object, | |
3104 java_lang_Thread::RUNNABLE); | |
3105 | |
3106 // The VM preresolve methods to these classes. Make sure that get initialized | |
3107 initialize_class(vmSymbolHandles::java_lang_reflect_Method(), CHECK_0); | |
3108 initialize_class(vmSymbolHandles::java_lang_ref_Finalizer(), CHECK_0); | |
3109 // The VM creates & returns objects of this class. Make sure it's initialized. | |
3110 initialize_class(vmSymbolHandles::java_lang_Class(), CHECK_0); | |
3111 call_initializeSystemClass(CHECK_0); | |
3112 } else { | |
3113 warning("java.lang.System not initialized"); | |
3114 } | |
3115 | |
3116 // an instance of OutOfMemory exception has been allocated earlier | |
3117 if (InitializeJavaLangExceptionsErrors) { | |
3118 initialize_class(vmSymbolHandles::java_lang_OutOfMemoryError(), CHECK_0); | |
3119 initialize_class(vmSymbolHandles::java_lang_NullPointerException(), CHECK_0); | |
3120 initialize_class(vmSymbolHandles::java_lang_ClassCastException(), CHECK_0); | |
3121 initialize_class(vmSymbolHandles::java_lang_ArrayStoreException(), CHECK_0); | |
3122 initialize_class(vmSymbolHandles::java_lang_ArithmeticException(), CHECK_0); | |
3123 initialize_class(vmSymbolHandles::java_lang_StackOverflowError(), CHECK_0); | |
3124 initialize_class(vmSymbolHandles::java_lang_IllegalMonitorStateException(), CHECK_0); | |
3125 } else { | |
3126 warning("java.lang.OutOfMemoryError has not been initialized"); | |
3127 warning("java.lang.NullPointerException has not been initialized"); | |
3128 warning("java.lang.ClassCastException has not been initialized"); | |
3129 warning("java.lang.ArrayStoreException has not been initialized"); | |
3130 warning("java.lang.ArithmeticException has not been initialized"); | |
3131 warning("java.lang.StackOverflowError has not been initialized"); | |
3132 } | |
1135
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1027
diff
changeset
|
3133 |
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1027
diff
changeset
|
3134 if (EnableInvokeDynamic) { |
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1027
diff
changeset
|
3135 // JSR 292: An intialized java.dyn.InvokeDynamic is required in |
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1027
diff
changeset
|
3136 // the compiler. |
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1027
diff
changeset
|
3137 initialize_class(vmSymbolHandles::java_dyn_InvokeDynamic(), CHECK_0); |
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1027
diff
changeset
|
3138 } |
0 | 3139 } |
3140 | |
3141 // See : bugid 4211085. | |
3142 // Background : the static initializer of java.lang.Compiler tries to read | |
3143 // property"java.compiler" and read & write property "java.vm.info". | |
3144 // When a security manager is installed through the command line | |
3145 // option "-Djava.security.manager", the above properties are not | |
3146 // readable and the static initializer for java.lang.Compiler fails | |
3147 // resulting in a NoClassDefFoundError. This can happen in any | |
3148 // user code which calls methods in java.lang.Compiler. | |
3149 // Hack : the hack is to pre-load and initialize this class, so that only | |
3150 // system domains are on the stack when the properties are read. | |
3151 // Currently even the AWT code has calls to methods in java.lang.Compiler. | |
3152 // On the classic VM, java.lang.Compiler is loaded very early to load the JIT. | |
3153 // Future Fix : the best fix is to grant everyone permissions to read "java.compiler" and | |
3154 // read and write"java.vm.info" in the default policy file. See bugid 4211383 | |
3155 // Once that is done, we should remove this hack. | |
3156 initialize_class(vmSymbolHandles::java_lang_Compiler(), CHECK_0); | |
3157 | |
3158 // More hackery - the static initializer of java.lang.Compiler adds the string "nojit" to | |
3159 // the java.vm.info property if no jit gets loaded through java.lang.Compiler (the hotspot | |
3160 // compiler does not get loaded through java.lang.Compiler). "java -version" with the | |
3161 // hotspot vm says "nojit" all the time which is confusing. So, we reset it here. | |
3162 // This should also be taken out as soon as 4211383 gets fixed. | |
3163 reset_vm_info_property(CHECK_0); | |
3164 | |
3165 quicken_jni_functions(); | |
3166 | |
3167 // Set flag that basic initialization has completed. Used by exceptions and various | |
3168 // debug stuff, that does not work until all basic classes have been initialized. | |
3169 set_init_completed(); | |
3170 | |
3171 HS_DTRACE_PROBE(hotspot, vm__init__end); | |
3172 | |
3173 // record VM initialization completion time | |
3174 Management::record_vm_init_completed(); | |
3175 | |
3176 // Compute system loader. Note that this has to occur after set_init_completed, since | |
3177 // valid exceptions may be thrown in the process. | |
3178 // Note that we do not use CHECK_0 here since we are inside an EXCEPTION_MARK and | |
3179 // set_init_completed has just been called, causing exceptions not to be shortcut | |
3180 // anymore. We call vm_exit_during_initialization directly instead. | |
3181 SystemDictionary::compute_java_system_loader(THREAD); | |
3182 if (HAS_PENDING_EXCEPTION) { | |
3183 vm_exit_during_initialization(Handle(THREAD, PENDING_EXCEPTION)); | |
3184 } | |
3185 | |
1115
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
3186 #ifdef KERNEL |
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
3187 if (JDK_Version::is_gte_jdk17x_version()) { |
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
3188 set_jkernel_boot_classloader_hook(THREAD); |
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
3189 } |
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
3190 #endif // KERNEL |
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
3191 |
0 | 3192 #ifndef SERIALGC |
3193 // Support for ConcurrentMarkSweep. This should be cleaned up | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
3194 // and better encapsulated. The ugly nested if test would go away |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
3195 // once things are properly refactored. XXX YSR |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
3196 if (UseConcMarkSweepGC || UseG1GC) { |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
3197 if (UseConcMarkSweepGC) { |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
3198 ConcurrentMarkSweepThread::makeSurrogateLockerThread(THREAD); |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
3199 } else { |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
3200 ConcurrentMarkThread::makeSurrogateLockerThread(THREAD); |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
3201 } |
0 | 3202 if (HAS_PENDING_EXCEPTION) { |
3203 vm_exit_during_initialization(Handle(THREAD, PENDING_EXCEPTION)); | |
3204 } | |
3205 } | |
3206 #endif // SERIALGC | |
3207 | |
3208 // Always call even when there are not JVMTI environments yet, since environments | |
3209 // may be attached late and JVMTI must track phases of VM execution | |
3210 JvmtiExport::enter_live_phase(); | |
3211 | |
3212 // Signal Dispatcher needs to be started before VMInit event is posted | |
3213 os::signal_init(); | |
3214 | |
3215 // Start Attach Listener if +StartAttachListener or it can't be started lazily | |
3216 if (!DisableAttachMechanism) { | |
3217 if (StartAttachListener || AttachListener::init_at_startup()) { | |
3218 AttachListener::init(); | |
3219 } | |
3220 } | |
3221 | |
3222 // Launch -Xrun agents | |
3223 // Must be done in the JVMTI live phase so that for backward compatibility the JDWP | |
3224 // back-end can launch with -Xdebug -Xrunjdwp. | |
3225 if (!EagerXrunInit && Arguments::init_libraries_at_startup()) { | |
3226 create_vm_init_libraries(); | |
3227 } | |
3228 | |
3229 // Notify JVMTI agents that VM initialization is complete - nop if no agents. | |
3230 JvmtiExport::post_vm_initialized(); | |
3231 | |
3232 Chunk::start_chunk_pool_cleaner_task(); | |
3233 | |
3234 // initialize compiler(s) | |
3235 CompileBroker::compilation_init(); | |
3236 | |
3237 Management::initialize(THREAD); | |
3238 if (HAS_PENDING_EXCEPTION) { | |
3239 // management agent fails to start possibly due to | |
3240 // configuration problem and is responsible for printing | |
3241 // stack trace if appropriate. Simply exit VM. | |
3242 vm_exit(1); | |
3243 } | |
3244 | |
3245 if (Arguments::has_profile()) FlatProfiler::engage(main_thread, true); | |
3246 if (Arguments::has_alloc_profile()) AllocationProfiler::engage(); | |
3247 if (MemProfiling) MemProfiler::engage(); | |
3248 StatSampler::engage(); | |
3249 if (CheckJNICalls) JniPeriodicChecker::engage(); | |
3250 | |
3251 BiasedLocking::init(); | |
3252 | |
3253 | |
3254 // Start up the WatcherThread if there are any periodic tasks | |
3255 // NOTE: All PeriodicTasks should be registered by now. If they | |
3256 // aren't, late joiners might appear to start slowly (we might | |
3257 // take a while to process their first tick). | |
3258 if (PeriodicTask::num_tasks() > 0) { | |
3259 WatcherThread::start(); | |
3260 } | |
3261 | |
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
3262 // Give os specific code one last chance to start |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
3263 os::init_3(); |
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1608
diff
changeset
|
3264 |
0 | 3265 create_vm_timer.end(); |
3266 return JNI_OK; | |
3267 } | |
3268 | |
3269 // type for the Agent_OnLoad and JVM_OnLoad entry points | |
3270 extern "C" { | |
3271 typedef jint (JNICALL *OnLoadEntry_t)(JavaVM *, char *, void *); | |
3272 } | |
3273 // Find a command line agent library and return its entry point for | |
3274 // -agentlib: -agentpath: -Xrun | |
3275 // num_symbol_entries must be passed-in since only the caller knows the number of symbols in the array. | |
3276 static OnLoadEntry_t lookup_on_load(AgentLibrary* agent, const char *on_load_symbols[], size_t num_symbol_entries) { | |
3277 OnLoadEntry_t on_load_entry = NULL; | |
3278 void *library = agent->os_lib(); // check if we have looked it up before | |
3279 | |
3280 if (library == NULL) { | |
3281 char buffer[JVM_MAXPATHLEN]; | |
3282 char ebuf[1024]; | |
3283 const char *name = agent->name(); | |
1694
ab3fd720516c
6378314: Bad warning message when agent library not found. local directory is not searched.
rasbold
parents:
1681
diff
changeset
|
3284 const char *msg = "Could not find agent library "; |
0 | 3285 |
3286 if (agent->is_absolute_path()) { | |
3287 library = hpi::dll_load(name, ebuf, sizeof ebuf); | |
3288 if (library == NULL) { | |
1694
ab3fd720516c
6378314: Bad warning message when agent library not found. local directory is not searched.
rasbold
parents:
1681
diff
changeset
|
3289 const char *sub_msg = " in absolute path, with error: "; |
ab3fd720516c
6378314: Bad warning message when agent library not found. local directory is not searched.
rasbold
parents:
1681
diff
changeset
|
3290 size_t len = strlen(msg) + strlen(name) + strlen(sub_msg) + strlen(ebuf) + 1; |
ab3fd720516c
6378314: Bad warning message when agent library not found. local directory is not searched.
rasbold
parents:
1681
diff
changeset
|
3291 char *buf = NEW_C_HEAP_ARRAY(char, len); |
ab3fd720516c
6378314: Bad warning message when agent library not found. local directory is not searched.
rasbold
parents:
1681
diff
changeset
|
3292 jio_snprintf(buf, len, "%s%s%s%s", msg, name, sub_msg, ebuf); |
0 | 3293 // If we can't find the agent, exit. |
1694
ab3fd720516c
6378314: Bad warning message when agent library not found. local directory is not searched.
rasbold
parents:
1681
diff
changeset
|
3294 vm_exit_during_initialization(buf, NULL); |
ab3fd720516c
6378314: Bad warning message when agent library not found. local directory is not searched.
rasbold
parents:
1681
diff
changeset
|
3295 FREE_C_HEAP_ARRAY(char, buf); |
0 | 3296 } |
3297 } else { | |
3298 // Try to load the agent from the standard dll directory | |
3299 hpi::dll_build_name(buffer, sizeof(buffer), Arguments::get_dll_dir(), name); | |
3300 library = hpi::dll_load(buffer, ebuf, sizeof ebuf); | |
3301 #ifdef KERNEL | |
3302 // Download instrument dll | |
3303 if (library == NULL && strcmp(name, "instrument") == 0) { | |
3304 char *props = Arguments::get_kernel_properties(); | |
3305 char *home = Arguments::get_java_home(); | |
3306 const char *fmt = "%s/bin/java %s -Dkernel.background.download=false" | |
3307 " sun.jkernel.DownloadManager -download client_jvm"; | |
1694
ab3fd720516c
6378314: Bad warning message when agent library not found. local directory is not searched.
rasbold
parents:
1681
diff
changeset
|
3308 size_t length = strlen(props) + strlen(home) + strlen(fmt) + 1; |
ab3fd720516c
6378314: Bad warning message when agent library not found. local directory is not searched.
rasbold
parents:
1681
diff
changeset
|
3309 char *cmd = NEW_C_HEAP_ARRAY(char, length); |
0 | 3310 jio_snprintf(cmd, length, fmt, home, props); |
3311 int status = os::fork_and_exec(cmd); | |
3312 FreeHeap(props); | |
3313 if (status == -1) { | |
3314 warning(cmd); | |
3315 vm_exit_during_initialization("fork_and_exec failed: %s", | |
3316 strerror(errno)); | |
3317 } | |
1694
ab3fd720516c
6378314: Bad warning message when agent library not found. local directory is not searched.
rasbold
parents:
1681
diff
changeset
|
3318 FREE_C_HEAP_ARRAY(char, cmd); |
0 | 3319 // when this comes back the instrument.dll should be where it belongs. |
3320 library = hpi::dll_load(buffer, ebuf, sizeof ebuf); | |
3321 } | |
3322 #endif // KERNEL | |
3323 if (library == NULL) { // Try the local directory | |
3324 char ns[1] = {0}; | |
3325 hpi::dll_build_name(buffer, sizeof(buffer), ns, name); | |
3326 library = hpi::dll_load(buffer, ebuf, sizeof ebuf); | |
3327 if (library == NULL) { | |
1694
ab3fd720516c
6378314: Bad warning message when agent library not found. local directory is not searched.
rasbold
parents:
1681
diff
changeset
|
3328 const char *sub_msg = " on the library path, with error: "; |
ab3fd720516c
6378314: Bad warning message when agent library not found. local directory is not searched.
rasbold
parents:
1681
diff
changeset
|
3329 size_t len = strlen(msg) + strlen(name) + strlen(sub_msg) + strlen(ebuf) + 1; |
ab3fd720516c
6378314: Bad warning message when agent library not found. local directory is not searched.
rasbold
parents:
1681
diff
changeset
|
3330 char *buf = NEW_C_HEAP_ARRAY(char, len); |
ab3fd720516c
6378314: Bad warning message when agent library not found. local directory is not searched.
rasbold
parents:
1681
diff
changeset
|
3331 jio_snprintf(buf, len, "%s%s%s%s", msg, name, sub_msg, ebuf); |
0 | 3332 // If we can't find the agent, exit. |
1694
ab3fd720516c
6378314: Bad warning message when agent library not found. local directory is not searched.
rasbold
parents:
1681
diff
changeset
|
3333 vm_exit_during_initialization(buf, NULL); |
ab3fd720516c
6378314: Bad warning message when agent library not found. local directory is not searched.
rasbold
parents:
1681
diff
changeset
|
3334 FREE_C_HEAP_ARRAY(char, buf); |
0 | 3335 } |
3336 } | |
3337 } | |
3338 agent->set_os_lib(library); | |
3339 } | |
3340 | |
3341 // Find the OnLoad function. | |
3342 for (size_t symbol_index = 0; symbol_index < num_symbol_entries; symbol_index++) { | |
3343 on_load_entry = CAST_TO_FN_PTR(OnLoadEntry_t, hpi::dll_lookup(library, on_load_symbols[symbol_index])); | |
3344 if (on_load_entry != NULL) break; | |
3345 } | |
3346 return on_load_entry; | |
3347 } | |
3348 | |
3349 // Find the JVM_OnLoad entry point | |
3350 static OnLoadEntry_t lookup_jvm_on_load(AgentLibrary* agent) { | |
3351 const char *on_load_symbols[] = JVM_ONLOAD_SYMBOLS; | |
3352 return lookup_on_load(agent, on_load_symbols, sizeof(on_load_symbols) / sizeof(char*)); | |
3353 } | |
3354 | |
3355 // Find the Agent_OnLoad entry point | |
3356 static OnLoadEntry_t lookup_agent_on_load(AgentLibrary* agent) { | |
3357 const char *on_load_symbols[] = AGENT_ONLOAD_SYMBOLS; | |
3358 return lookup_on_load(agent, on_load_symbols, sizeof(on_load_symbols) / sizeof(char*)); | |
3359 } | |
3360 | |
3361 // For backwards compatibility with -Xrun | |
3362 // Convert libraries with no JVM_OnLoad, but which have Agent_OnLoad to be | |
3363 // treated like -agentpath: | |
3364 // Must be called before agent libraries are created | |
3365 void Threads::convert_vm_init_libraries_to_agents() { | |
3366 AgentLibrary* agent; | |
3367 AgentLibrary* next; | |
3368 | |
3369 for (agent = Arguments::libraries(); agent != NULL; agent = next) { | |
3370 next = agent->next(); // cache the next agent now as this agent may get moved off this list | |
3371 OnLoadEntry_t on_load_entry = lookup_jvm_on_load(agent); | |
3372 | |
3373 // If there is an JVM_OnLoad function it will get called later, | |
3374 // otherwise see if there is an Agent_OnLoad | |
3375 if (on_load_entry == NULL) { | |
3376 on_load_entry = lookup_agent_on_load(agent); | |
3377 if (on_load_entry != NULL) { | |
3378 // switch it to the agent list -- so that Agent_OnLoad will be called, | |
3379 // JVM_OnLoad won't be attempted and Agent_OnUnload will | |
3380 Arguments::convert_library_to_agent(agent); | |
3381 } else { | |
3382 vm_exit_during_initialization("Could not find JVM_OnLoad or Agent_OnLoad function in the library", agent->name()); | |
3383 } | |
3384 } | |
3385 } | |
3386 } | |
3387 | |
3388 // Create agents for -agentlib: -agentpath: and converted -Xrun | |
3389 // Invokes Agent_OnLoad | |
3390 // Called very early -- before JavaThreads exist | |
3391 void Threads::create_vm_init_agents() { | |
3392 extern struct JavaVM_ main_vm; | |
3393 AgentLibrary* agent; | |
3394 | |
3395 JvmtiExport::enter_onload_phase(); | |
3396 for (agent = Arguments::agents(); agent != NULL; agent = agent->next()) { | |
3397 OnLoadEntry_t on_load_entry = lookup_agent_on_load(agent); | |
3398 | |
3399 if (on_load_entry != NULL) { | |
3400 // Invoke the Agent_OnLoad function | |
3401 jint err = (*on_load_entry)(&main_vm, agent->options(), NULL); | |
3402 if (err != JNI_OK) { | |
3403 vm_exit_during_initialization("agent library failed to init", agent->name()); | |
3404 } | |
3405 } else { | |
3406 vm_exit_during_initialization("Could not find Agent_OnLoad function in the agent library", agent->name()); | |
3407 } | |
3408 } | |
3409 JvmtiExport::enter_primordial_phase(); | |
3410 } | |
3411 | |
3412 extern "C" { | |
3413 typedef void (JNICALL *Agent_OnUnload_t)(JavaVM *); | |
3414 } | |
3415 | |
3416 void Threads::shutdown_vm_agents() { | |
3417 // Send any Agent_OnUnload notifications | |
3418 const char *on_unload_symbols[] = AGENT_ONUNLOAD_SYMBOLS; | |
3419 extern struct JavaVM_ main_vm; | |
3420 for (AgentLibrary* agent = Arguments::agents(); agent != NULL; agent = agent->next()) { | |
3421 | |
3422 // Find the Agent_OnUnload function. | |
3423 for (uint symbol_index = 0; symbol_index < ARRAY_SIZE(on_unload_symbols); symbol_index++) { | |
3424 Agent_OnUnload_t unload_entry = CAST_TO_FN_PTR(Agent_OnUnload_t, | |
3425 hpi::dll_lookup(agent->os_lib(), on_unload_symbols[symbol_index])); | |
3426 | |
3427 // Invoke the Agent_OnUnload function | |
3428 if (unload_entry != NULL) { | |
3429 JavaThread* thread = JavaThread::current(); | |
3430 ThreadToNativeFromVM ttn(thread); | |
3431 HandleMark hm(thread); | |
3432 (*unload_entry)(&main_vm); | |
3433 break; | |
3434 } | |
3435 } | |
3436 } | |
3437 } | |
3438 | |
3439 // Called for after the VM is initialized for -Xrun libraries which have not been converted to agent libraries | |
3440 // Invokes JVM_OnLoad | |
3441 void Threads::create_vm_init_libraries() { | |
3442 extern struct JavaVM_ main_vm; | |
3443 AgentLibrary* agent; | |
3444 | |
3445 for (agent = Arguments::libraries(); agent != NULL; agent = agent->next()) { | |
3446 OnLoadEntry_t on_load_entry = lookup_jvm_on_load(agent); | |
3447 | |
3448 if (on_load_entry != NULL) { | |
3449 // Invoke the JVM_OnLoad function | |
3450 JavaThread* thread = JavaThread::current(); | |
3451 ThreadToNativeFromVM ttn(thread); | |
3452 HandleMark hm(thread); | |
3453 jint err = (*on_load_entry)(&main_vm, agent->options(), NULL); | |
3454 if (err != JNI_OK) { | |
3455 vm_exit_during_initialization("-Xrun library failed to init", agent->name()); | |
3456 } | |
3457 } else { | |
3458 vm_exit_during_initialization("Could not find JVM_OnLoad function in -Xrun library", agent->name()); | |
3459 } | |
3460 } | |
3461 } | |
3462 | |
3463 // Last thread running calls java.lang.Shutdown.shutdown() | |
3464 void JavaThread::invoke_shutdown_hooks() { | |
3465 HandleMark hm(this); | |
3466 | |
3467 // We could get here with a pending exception, if so clear it now. | |
3468 if (this->has_pending_exception()) { | |
3469 this->clear_pending_exception(); | |
3470 } | |
3471 | |
3472 EXCEPTION_MARK; | |
3473 klassOop k = | |
3474 SystemDictionary::resolve_or_null(vmSymbolHandles::java_lang_Shutdown(), | |
3475 THREAD); | |
3476 if (k != NULL) { | |
3477 // SystemDictionary::resolve_or_null will return null if there was | |
3478 // an exception. If we cannot load the Shutdown class, just don't | |
3479 // call Shutdown.shutdown() at all. This will mean the shutdown hooks | |
3480 // and finalizers (if runFinalizersOnExit is set) won't be run. | |
3481 // Note that if a shutdown hook was registered or runFinalizersOnExit | |
3482 // was called, the Shutdown class would have already been loaded | |
3483 // (Runtime.addShutdownHook and runFinalizersOnExit will load it). | |
3484 instanceKlassHandle shutdown_klass (THREAD, k); | |
3485 JavaValue result(T_VOID); | |
3486 JavaCalls::call_static(&result, | |
3487 shutdown_klass, | |
3488 vmSymbolHandles::shutdown_method_name(), | |
3489 vmSymbolHandles::void_method_signature(), | |
3490 THREAD); | |
3491 } | |
3492 CLEAR_PENDING_EXCEPTION; | |
3493 } | |
3494 | |
3495 // Threads::destroy_vm() is normally called from jni_DestroyJavaVM() when | |
3496 // the program falls off the end of main(). Another VM exit path is through | |
3497 // vm_exit() when the program calls System.exit() to return a value or when | |
3498 // there is a serious error in VM. The two shutdown paths are not exactly | |
3499 // the same, but they share Shutdown.shutdown() at Java level and before_exit() | |
3500 // and VM_Exit op at VM level. | |
3501 // | |
3502 // Shutdown sequence: | |
3503 // + Wait until we are the last non-daemon thread to execute | |
3504 // <-- every thing is still working at this moment --> | |
3505 // + Call java.lang.Shutdown.shutdown(), which will invoke Java level | |
3506 // shutdown hooks, run finalizers if finalization-on-exit | |
3507 // + Call before_exit(), prepare for VM exit | |
3508 // > run VM level shutdown hooks (they are registered through JVM_OnExit(), | |
3509 // currently the only user of this mechanism is File.deleteOnExit()) | |
3510 // > stop flat profiler, StatSampler, watcher thread, CMS threads, | |
3511 // post thread end and vm death events to JVMTI, | |
3512 // stop signal thread | |
3513 // + Call JavaThread::exit(), it will: | |
3514 // > release JNI handle blocks, remove stack guard pages | |
3515 // > remove this thread from Threads list | |
3516 // <-- no more Java code from this thread after this point --> | |
3517 // + Stop VM thread, it will bring the remaining VM to a safepoint and stop | |
3518 // the compiler threads at safepoint | |
3519 // <-- do not use anything that could get blocked by Safepoint --> | |
3520 // + Disable tracing at JNI/JVM barriers | |
3521 // + Set _vm_exited flag for threads that are still running native code | |
3522 // + Delete this thread | |
3523 // + Call exit_globals() | |
3524 // > deletes tty | |
3525 // > deletes PerfMemory resources | |
3526 // + Return to caller | |
3527 | |
3528 bool Threads::destroy_vm() { | |
3529 JavaThread* thread = JavaThread::current(); | |
3530 | |
3531 // Wait until we are the last non-daemon thread to execute | |
3532 { MutexLocker nu(Threads_lock); | |
3533 while (Threads::number_of_non_daemon_threads() > 1 ) | |
3534 // This wait should make safepoint checks, wait without a timeout, | |
3535 // and wait as a suspend-equivalent condition. | |
3536 // | |
3537 // Note: If the FlatProfiler is running and this thread is waiting | |
3538 // for another non-daemon thread to finish, then the FlatProfiler | |
3539 // is waiting for the external suspend request on this thread to | |
3540 // complete. wait_for_ext_suspend_completion() will eventually | |
3541 // timeout, but that takes time. Making this wait a suspend- | |
3542 // equivalent condition solves that timeout problem. | |
3543 // | |
3544 Threads_lock->wait(!Mutex::_no_safepoint_check_flag, 0, | |
3545 Mutex::_as_suspend_equivalent_flag); | |
3546 } | |
3547 | |
3548 // Hang forever on exit if we are reporting an error. | |
3549 if (ShowMessageBoxOnError && is_error_reported()) { | |
3550 os::infinite_sleep(); | |
3551 } | |
3552 | |
3553 if (JDK_Version::is_jdk12x_version()) { | |
3554 // We are the last thread running, so check if finalizers should be run. | |
3555 // For 1.3 or later this is done in thread->invoke_shutdown_hooks() | |
3556 HandleMark rm(thread); | |
3557 Universe::run_finalizers_on_exit(); | |
3558 } else { | |
3559 // run Java level shutdown hooks | |
3560 thread->invoke_shutdown_hooks(); | |
3561 } | |
3562 | |
3563 before_exit(thread); | |
3564 | |
3565 thread->exit(true); | |
3566 | |
3567 // Stop VM thread. | |
3568 { | |
3569 // 4945125 The vm thread comes to a safepoint during exit. | |
3570 // GC vm_operations can get caught at the safepoint, and the | |
3571 // heap is unparseable if they are caught. Grab the Heap_lock | |
3572 // to prevent this. The GC vm_operations will not be able to | |
3573 // queue until after the vm thread is dead. | |
3574 MutexLocker ml(Heap_lock); | |
3575 | |
3576 VMThread::wait_for_vm_thread_exit(); | |
3577 assert(SafepointSynchronize::is_at_safepoint(), "VM thread should exit at Safepoint"); | |
3578 VMThread::destroy(); | |
3579 } | |
3580 | |
3581 // clean up ideal graph printers | |
3582 #if defined(COMPILER2) && !defined(PRODUCT) | |
3583 IdealGraphPrinter::clean_up(); | |
3584 #endif | |
3585 | |
3586 // Now, all Java threads are gone except daemon threads. Daemon threads | |
3587 // running Java code or in VM are stopped by the Safepoint. However, | |
3588 // daemon threads executing native code are still running. But they | |
3589 // will be stopped at native=>Java/VM barriers. Note that we can't | |
3590 // simply kill or suspend them, as it is inherently deadlock-prone. | |
3591 | |
3592 #ifndef PRODUCT | |
3593 // disable function tracing at JNI/JVM barriers | |
3594 TraceHPI = false; | |
3595 TraceJNICalls = false; | |
3596 TraceJVMCalls = false; | |
3597 TraceRuntimeCalls = false; | |
3598 #endif | |
3599 | |
3600 VM_Exit::set_vm_exited(); | |
3601 | |
3602 notify_vm_shutdown(); | |
3603 | |
3604 delete thread; | |
3605 | |
3606 // exit_globals() will delete tty | |
3607 exit_globals(); | |
3608 | |
3609 return true; | |
3610 } | |
3611 | |
3612 | |
3613 jboolean Threads::is_supported_jni_version_including_1_1(jint version) { | |
3614 if (version == JNI_VERSION_1_1) return JNI_TRUE; | |
3615 return is_supported_jni_version(version); | |
3616 } | |
3617 | |
3618 | |
3619 jboolean Threads::is_supported_jni_version(jint version) { | |
3620 if (version == JNI_VERSION_1_2) return JNI_TRUE; | |
3621 if (version == JNI_VERSION_1_4) return JNI_TRUE; | |
3622 if (version == JNI_VERSION_1_6) return JNI_TRUE; | |
3623 return JNI_FALSE; | |
3624 } | |
3625 | |
3626 | |
3627 void Threads::add(JavaThread* p, bool force_daemon) { | |
3628 // The threads lock must be owned at this point | |
3629 assert_locked_or_safepoint(Threads_lock); | |
3630 p->set_next(_thread_list); | |
3631 _thread_list = p; | |
3632 _number_of_threads++; | |
3633 oop threadObj = p->threadObj(); | |
3634 bool daemon = true; | |
3635 // Bootstrapping problem: threadObj can be null for initial | |
3636 // JavaThread (or for threads attached via JNI) | |
3637 if ((!force_daemon) && (threadObj == NULL || !java_lang_Thread::is_daemon(threadObj))) { | |
3638 _number_of_non_daemon_threads++; | |
3639 daemon = false; | |
3640 } | |
3641 | |
3642 ThreadService::add_thread(p, daemon); | |
3643 | |
3644 // Possible GC point. | |
3645 Events::log("Thread added: " INTPTR_FORMAT, p); | |
3646 } | |
3647 | |
3648 void Threads::remove(JavaThread* p) { | |
3649 // Extra scope needed for Thread_lock, so we can check | |
3650 // that we do not remove thread without safepoint code notice | |
3651 { MutexLocker ml(Threads_lock); | |
3652 | |
3653 assert(includes(p), "p must be present"); | |
3654 | |
3655 JavaThread* current = _thread_list; | |
3656 JavaThread* prev = NULL; | |
3657 | |
3658 while (current != p) { | |
3659 prev = current; | |
3660 current = current->next(); | |
3661 } | |
3662 | |
3663 if (prev) { | |
3664 prev->set_next(current->next()); | |
3665 } else { | |
3666 _thread_list = p->next(); | |
3667 } | |
3668 _number_of_threads--; | |
3669 oop threadObj = p->threadObj(); | |
3670 bool daemon = true; | |
3671 if (threadObj == NULL || !java_lang_Thread::is_daemon(threadObj)) { | |
3672 _number_of_non_daemon_threads--; | |
3673 daemon = false; | |
3674 | |
3675 // Only one thread left, do a notify on the Threads_lock so a thread waiting | |
3676 // on destroy_vm will wake up. | |
3677 if (number_of_non_daemon_threads() == 1) | |
3678 Threads_lock->notify_all(); | |
3679 } | |
3680 ThreadService::remove_thread(p, daemon); | |
3681 | |
3682 // Make sure that safepoint code disregard this thread. This is needed since | |
3683 // the thread might mess around with locks after this point. This can cause it | |
3684 // to do callbacks into the safepoint code. However, the safepoint code is not aware | |
3685 // of this thread since it is removed from the queue. | |
3686 p->set_terminated_value(); | |
3687 } // unlock Threads_lock | |
3688 | |
3689 // Since Events::log uses a lock, we grab it outside the Threads_lock | |
3690 Events::log("Thread exited: " INTPTR_FORMAT, p); | |
3691 } | |
3692 | |
3693 // Threads_lock must be held when this is called (or must be called during a safepoint) | |
3694 bool Threads::includes(JavaThread* p) { | |
3695 assert(Threads_lock->is_locked(), "sanity check"); | |
3696 ALL_JAVA_THREADS(q) { | |
3697 if (q == p ) { | |
3698 return true; | |
3699 } | |
3700 } | |
3701 return false; | |
3702 } | |
3703 | |
3704 // Operations on the Threads list for GC. These are not explicitly locked, | |
3705 // but the garbage collector must provide a safe context for them to run. | |
3706 // In particular, these things should never be called when the Threads_lock | |
3707 // is held by some other thread. (Note: the Safepoint abstraction also | |
3708 // uses the Threads_lock to gurantee this property. It also makes sure that | |
3709 // all threads gets blocked when exiting or starting). | |
3710 | |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
3711 void Threads::oops_do(OopClosure* f, CodeBlobClosure* cf) { |
0 | 3712 ALL_JAVA_THREADS(p) { |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
3713 p->oops_do(f, cf); |
0 | 3714 } |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
3715 VMThread::vm_thread()->oops_do(f, cf); |
0 | 3716 } |
3717 | |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
3718 void Threads::possibly_parallel_oops_do(OopClosure* f, CodeBlobClosure* cf) { |
0 | 3719 // Introduce a mechanism allowing parallel threads to claim threads as |
3720 // root groups. Overhead should be small enough to use all the time, | |
3721 // even in sequential code. | |
3722 SharedHeap* sh = SharedHeap::heap(); | |
3723 bool is_par = (sh->n_par_threads() > 0); | |
3724 int cp = SharedHeap::heap()->strong_roots_parity(); | |
3725 ALL_JAVA_THREADS(p) { | |
3726 if (p->claim_oops_do(is_par, cp)) { | |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
3727 p->oops_do(f, cf); |
0 | 3728 } |
3729 } | |
3730 VMThread* vmt = VMThread::vm_thread(); | |
3731 if (vmt->claim_oops_do(is_par, cp)) | |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
3732 vmt->oops_do(f, cf); |
0 | 3733 } |
3734 | |
3735 #ifndef SERIALGC | |
3736 // Used by ParallelScavenge | |
3737 void Threads::create_thread_roots_tasks(GCTaskQueue* q) { | |
3738 ALL_JAVA_THREADS(p) { | |
3739 q->enqueue(new ThreadRootsTask(p)); | |
3740 } | |
3741 q->enqueue(new ThreadRootsTask(VMThread::vm_thread())); | |
3742 } | |
3743 | |
3744 // Used by Parallel Old | |
3745 void Threads::create_thread_roots_marking_tasks(GCTaskQueue* q) { | |
3746 ALL_JAVA_THREADS(p) { | |
3747 q->enqueue(new ThreadRootsMarkingTask(p)); | |
3748 } | |
3749 q->enqueue(new ThreadRootsMarkingTask(VMThread::vm_thread())); | |
3750 } | |
3751 #endif // SERIALGC | |
3752 | |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
3753 void Threads::nmethods_do(CodeBlobClosure* cf) { |
0 | 3754 ALL_JAVA_THREADS(p) { |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
3755 p->nmethods_do(cf); |
0 | 3756 } |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
3757 VMThread::vm_thread()->nmethods_do(cf); |
0 | 3758 } |
3759 | |
3760 void Threads::gc_epilogue() { | |
3761 ALL_JAVA_THREADS(p) { | |
3762 p->gc_epilogue(); | |
3763 } | |
3764 } | |
3765 | |
3766 void Threads::gc_prologue() { | |
3767 ALL_JAVA_THREADS(p) { | |
3768 p->gc_prologue(); | |
3769 } | |
3770 } | |
3771 | |
3772 void Threads::deoptimized_wrt_marked_nmethods() { | |
3773 ALL_JAVA_THREADS(p) { | |
3774 p->deoptimized_wrt_marked_nmethods(); | |
3775 } | |
3776 } | |
3777 | |
3778 | |
3779 // Get count Java threads that are waiting to enter the specified monitor. | |
3780 GrowableArray<JavaThread*>* Threads::get_pending_threads(int count, | |
3781 address monitor, bool doLock) { | |
3782 assert(doLock || SafepointSynchronize::is_at_safepoint(), | |
3783 "must grab Threads_lock or be at safepoint"); | |
3784 GrowableArray<JavaThread*>* result = new GrowableArray<JavaThread*>(count); | |
3785 | |
3786 int i = 0; | |
3787 { | |
3788 MutexLockerEx ml(doLock ? Threads_lock : NULL); | |
3789 ALL_JAVA_THREADS(p) { | |
3790 if (p->is_Compiler_thread()) continue; | |
3791 | |
3792 address pending = (address)p->current_pending_monitor(); | |
3793 if (pending == monitor) { // found a match | |
3794 if (i < count) result->append(p); // save the first count matches | |
3795 i++; | |
3796 } | |
3797 } | |
3798 } | |
3799 return result; | |
3800 } | |
3801 | |
3802 | |
3803 JavaThread *Threads::owning_thread_from_monitor_owner(address owner, bool doLock) { | |
3804 assert(doLock || | |
3805 Threads_lock->owned_by_self() || | |
3806 SafepointSynchronize::is_at_safepoint(), | |
3807 "must grab Threads_lock or be at safepoint"); | |
3808 | |
3809 // NULL owner means not locked so we can skip the search | |
3810 if (owner == NULL) return NULL; | |
3811 | |
3812 { | |
3813 MutexLockerEx ml(doLock ? Threads_lock : NULL); | |
3814 ALL_JAVA_THREADS(p) { | |
3815 // first, see if owner is the address of a Java thread | |
3816 if (owner == (address)p) return p; | |
3817 } | |
3818 } | |
3819 assert(UseHeavyMonitors == false, "Did not find owning Java thread with UseHeavyMonitors enabled"); | |
3820 if (UseHeavyMonitors) return NULL; | |
3821 | |
3822 // | |
3823 // If we didn't find a matching Java thread and we didn't force use of | |
3824 // heavyweight monitors, then the owner is the stack address of the | |
3825 // Lock Word in the owning Java thread's stack. | |
3826 // | |
3827 JavaThread* the_owner = NULL; | |
3828 { | |
3829 MutexLockerEx ml(doLock ? Threads_lock : NULL); | |
3830 ALL_JAVA_THREADS(q) { | |
702
b9fba36710f2
6699669: Hotspot server leaves synchronized block with monitor in bad state
xlu
parents:
669
diff
changeset
|
3831 if (q->is_lock_owned(owner)) { |
0 | 3832 the_owner = q; |
702
b9fba36710f2
6699669: Hotspot server leaves synchronized block with monitor in bad state
xlu
parents:
669
diff
changeset
|
3833 break; |
0 | 3834 } |
3835 } | |
3836 } | |
3837 assert(the_owner != NULL, "Did not find owning Java thread for lock word address"); | |
3838 return the_owner; | |
3839 } | |
3840 | |
3841 // Threads::print_on() is called at safepoint by VM_PrintThreads operation. | |
3842 void Threads::print_on(outputStream* st, bool print_stacks, bool internal_format, bool print_concurrent_locks) { | |
3843 char buf[32]; | |
3844 st->print_cr(os::local_time_string(buf, sizeof(buf))); | |
3845 | |
3846 st->print_cr("Full thread dump %s (%s %s):", | |
3847 Abstract_VM_Version::vm_name(), | |
3848 Abstract_VM_Version::vm_release(), | |
3849 Abstract_VM_Version::vm_info_string() | |
3850 ); | |
3851 st->cr(); | |
3852 | |
3853 #ifndef SERIALGC | |
3854 // Dump concurrent locks | |
3855 ConcurrentLocksDump concurrent_locks; | |
3856 if (print_concurrent_locks) { | |
3857 concurrent_locks.dump_at_safepoint(); | |
3858 } | |
3859 #endif // SERIALGC | |
3860 | |
3861 ALL_JAVA_THREADS(p) { | |
3862 ResourceMark rm; | |
3863 p->print_on(st); | |
3864 if (print_stacks) { | |
3865 if (internal_format) { | |
3866 p->trace_stack(); | |
3867 } else { | |
3868 p->print_stack_on(st); | |
3869 } | |
3870 } | |
3871 st->cr(); | |
3872 #ifndef SERIALGC | |
3873 if (print_concurrent_locks) { | |
3874 concurrent_locks.print_locks_on(p, st); | |
3875 } | |
3876 #endif // SERIALGC | |
3877 } | |
3878 | |
3879 VMThread::vm_thread()->print_on(st); | |
3880 st->cr(); | |
3881 Universe::heap()->print_gc_threads_on(st); | |
3882 WatcherThread* wt = WatcherThread::watcher_thread(); | |
3883 if (wt != NULL) wt->print_on(st); | |
3884 st->cr(); | |
3885 CompileBroker::print_compiler_threads_on(st); | |
3886 st->flush(); | |
3887 } | |
3888 | |
3889 // Threads::print_on_error() is called by fatal error handler. It's possible | |
3890 // that VM is not at safepoint and/or current thread is inside signal handler. | |
3891 // Don't print stack trace, as the stack may not be walkable. Don't allocate | |
3892 // memory (even in resource area), it might deadlock the error handler. | |
3893 void Threads::print_on_error(outputStream* st, Thread* current, char* buf, int buflen) { | |
3894 bool found_current = false; | |
3895 st->print_cr("Java Threads: ( => current thread )"); | |
3896 ALL_JAVA_THREADS(thread) { | |
3897 bool is_current = (current == thread); | |
3898 found_current = found_current || is_current; | |
3899 | |
3900 st->print("%s", is_current ? "=>" : " "); | |
3901 | |
3902 st->print(PTR_FORMAT, thread); | |
3903 st->print(" "); | |
3904 thread->print_on_error(st, buf, buflen); | |
3905 st->cr(); | |
3906 } | |
3907 st->cr(); | |
3908 | |
3909 st->print_cr("Other Threads:"); | |
3910 if (VMThread::vm_thread()) { | |
3911 bool is_current = (current == VMThread::vm_thread()); | |
3912 found_current = found_current || is_current; | |
3913 st->print("%s", current == VMThread::vm_thread() ? "=>" : " "); | |
3914 | |
3915 st->print(PTR_FORMAT, VMThread::vm_thread()); | |
3916 st->print(" "); | |
3917 VMThread::vm_thread()->print_on_error(st, buf, buflen); | |
3918 st->cr(); | |
3919 } | |
3920 WatcherThread* wt = WatcherThread::watcher_thread(); | |
3921 if (wt != NULL) { | |
3922 bool is_current = (current == wt); | |
3923 found_current = found_current || is_current; | |
3924 st->print("%s", is_current ? "=>" : " "); | |
3925 | |
3926 st->print(PTR_FORMAT, wt); | |
3927 st->print(" "); | |
3928 wt->print_on_error(st, buf, buflen); | |
3929 st->cr(); | |
3930 } | |
3931 if (!found_current) { | |
3932 st->cr(); | |
3933 st->print("=>" PTR_FORMAT " (exited) ", current); | |
3934 current->print_on_error(st, buf, buflen); | |
3935 st->cr(); | |
3936 } | |
3937 } | |
3938 | |
3939 | |
3940 // Lifecycle management for TSM ParkEvents. | |
3941 // ParkEvents are type-stable (TSM). | |
3942 // In our particular implementation they happen to be immortal. | |
3943 // | |
3944 // We manage concurrency on the FreeList with a CAS-based | |
3945 // detach-modify-reattach idiom that avoids the ABA problems | |
3946 // that would otherwise be present in a simple CAS-based | |
3947 // push-pop implementation. (push-one and pop-all) | |
3948 // | |
3949 // Caveat: Allocate() and Release() may be called from threads | |
3950 // other than the thread associated with the Event! | |
3951 // If we need to call Allocate() when running as the thread in | |
3952 // question then look for the PD calls to initialize native TLS. | |
3953 // Native TLS (Win32/Linux/Solaris) can only be initialized or | |
3954 // accessed by the associated thread. | |
3955 // See also pd_initialize(). | |
3956 // | |
3957 // Note that we could defer associating a ParkEvent with a thread | |
3958 // until the 1st time the thread calls park(). unpark() calls to | |
3959 // an unprovisioned thread would be ignored. The first park() call | |
3960 // for a thread would allocate and associate a ParkEvent and return | |
3961 // immediately. | |
3962 | |
3963 volatile int ParkEvent::ListLock = 0 ; | |
3964 ParkEvent * volatile ParkEvent::FreeList = NULL ; | |
3965 | |
3966 ParkEvent * ParkEvent::Allocate (Thread * t) { | |
3967 // In rare cases -- JVM_RawMonitor* operations -- we can find t == null. | |
3968 ParkEvent * ev ; | |
3969 | |
3970 // Start by trying to recycle an existing but unassociated | |
3971 // ParkEvent from the global free list. | |
3972 for (;;) { | |
3973 ev = FreeList ; | |
3974 if (ev == NULL) break ; | |
3975 // 1: Detach - sequester or privatize the list | |
3976 // Tantamount to ev = Swap (&FreeList, NULL) | |
3977 if (Atomic::cmpxchg_ptr (NULL, &FreeList, ev) != ev) { | |
3978 continue ; | |
3979 } | |
3980 | |
3981 // We've detached the list. The list in-hand is now | |
3982 // local to this thread. This thread can operate on the | |
3983 // list without risk of interference from other threads. | |
3984 // 2: Extract -- pop the 1st element from the list. | |
3985 ParkEvent * List = ev->FreeNext ; | |
3986 if (List == NULL) break ; | |
3987 for (;;) { | |
3988 // 3: Try to reattach the residual list | |
3989 guarantee (List != NULL, "invariant") ; | |
3990 ParkEvent * Arv = (ParkEvent *) Atomic::cmpxchg_ptr (List, &FreeList, NULL) ; | |
3991 if (Arv == NULL) break ; | |
3992 | |
3993 // New nodes arrived. Try to detach the recent arrivals. | |
3994 if (Atomic::cmpxchg_ptr (NULL, &FreeList, Arv) != Arv) { | |
3995 continue ; | |
3996 } | |
3997 guarantee (Arv != NULL, "invariant") ; | |
3998 // 4: Merge Arv into List | |
3999 ParkEvent * Tail = List ; | |
4000 while (Tail->FreeNext != NULL) Tail = Tail->FreeNext ; | |
4001 Tail->FreeNext = Arv ; | |
4002 } | |
4003 break ; | |
4004 } | |
4005 | |
4006 if (ev != NULL) { | |
4007 guarantee (ev->AssociatedWith == NULL, "invariant") ; | |
4008 } else { | |
4009 // Do this the hard way -- materialize a new ParkEvent. | |
4010 // In rare cases an allocating thread might detach a long list -- | |
4011 // installing null into FreeList -- and then stall or be obstructed. | |
4012 // A 2nd thread calling Allocate() would see FreeList == null. | |
4013 // The list held privately by the 1st thread is unavailable to the 2nd thread. | |
4014 // In that case the 2nd thread would have to materialize a new ParkEvent, | |
4015 // even though free ParkEvents existed in the system. In this case we end up | |
4016 // with more ParkEvents in circulation than we need, but the race is | |
4017 // rare and the outcome is benign. Ideally, the # of extant ParkEvents | |
4018 // is equal to the maximum # of threads that existed at any one time. | |
4019 // Because of the race mentioned above, segments of the freelist | |
4020 // can be transiently inaccessible. At worst we may end up with the | |
4021 // # of ParkEvents in circulation slightly above the ideal. | |
4022 // Note that if we didn't have the TSM/immortal constraint, then | |
4023 // when reattaching, above, we could trim the list. | |
4024 ev = new ParkEvent () ; | |
4025 guarantee ((intptr_t(ev) & 0xFF) == 0, "invariant") ; | |
4026 } | |
4027 ev->reset() ; // courtesy to caller | |
4028 ev->AssociatedWith = t ; // Associate ev with t | |
4029 ev->FreeNext = NULL ; | |
4030 return ev ; | |
4031 } | |
4032 | |
4033 void ParkEvent::Release (ParkEvent * ev) { | |
4034 if (ev == NULL) return ; | |
4035 guarantee (ev->FreeNext == NULL , "invariant") ; | |
4036 ev->AssociatedWith = NULL ; | |
4037 for (;;) { | |
4038 // Push ev onto FreeList | |
4039 // The mechanism is "half" lock-free. | |
4040 ParkEvent * List = FreeList ; | |
4041 ev->FreeNext = List ; | |
4042 if (Atomic::cmpxchg_ptr (ev, &FreeList, List) == List) break ; | |
4043 } | |
4044 } | |
4045 | |
4046 // Override operator new and delete so we can ensure that the | |
4047 // least significant byte of ParkEvent addresses is 0. | |
4048 // Beware that excessive address alignment is undesirable | |
4049 // as it can result in D$ index usage imbalance as | |
4050 // well as bank access imbalance on Niagara-like platforms, | |
4051 // although Niagara's hash function should help. | |
4052 | |
4053 void * ParkEvent::operator new (size_t sz) { | |
4054 return (void *) ((intptr_t (CHeapObj::operator new (sz + 256)) + 256) & -256) ; | |
4055 } | |
4056 | |
4057 void ParkEvent::operator delete (void * a) { | |
4058 // ParkEvents are type-stable and immortal ... | |
4059 ShouldNotReachHere(); | |
4060 } | |
4061 | |
4062 | |
4063 // 6399321 As a temporary measure we copied & modified the ParkEvent:: | |
4064 // allocate() and release() code for use by Parkers. The Parker:: forms | |
4065 // will eventually be removed as we consolide and shift over to ParkEvents | |
4066 // for both builtin synchronization and JSR166 operations. | |
4067 | |
4068 volatile int Parker::ListLock = 0 ; | |
4069 Parker * volatile Parker::FreeList = NULL ; | |
4070 | |
4071 Parker * Parker::Allocate (JavaThread * t) { | |
4072 guarantee (t != NULL, "invariant") ; | |
4073 Parker * p ; | |
4074 | |
4075 // Start by trying to recycle an existing but unassociated | |
4076 // Parker from the global free list. | |
4077 for (;;) { | |
4078 p = FreeList ; | |
4079 if (p == NULL) break ; | |
4080 // 1: Detach | |
4081 // Tantamount to p = Swap (&FreeList, NULL) | |
4082 if (Atomic::cmpxchg_ptr (NULL, &FreeList, p) != p) { | |
4083 continue ; | |
4084 } | |
4085 | |
4086 // We've detached the list. The list in-hand is now | |
4087 // local to this thread. This thread can operate on the | |
4088 // list without risk of interference from other threads. | |
4089 // 2: Extract -- pop the 1st element from the list. | |
4090 Parker * List = p->FreeNext ; | |
4091 if (List == NULL) break ; | |
4092 for (;;) { | |
4093 // 3: Try to reattach the residual list | |
4094 guarantee (List != NULL, "invariant") ; | |
4095 Parker * Arv = (Parker *) Atomic::cmpxchg_ptr (List, &FreeList, NULL) ; | |
4096 if (Arv == NULL) break ; | |
4097 | |
4098 // New nodes arrived. Try to detach the recent arrivals. | |
4099 if (Atomic::cmpxchg_ptr (NULL, &FreeList, Arv) != Arv) { | |
4100 continue ; | |
4101 } | |
4102 guarantee (Arv != NULL, "invariant") ; | |
4103 // 4: Merge Arv into List | |
4104 Parker * Tail = List ; | |
4105 while (Tail->FreeNext != NULL) Tail = Tail->FreeNext ; | |
4106 Tail->FreeNext = Arv ; | |
4107 } | |
4108 break ; | |
4109 } | |
4110 | |
4111 if (p != NULL) { | |
4112 guarantee (p->AssociatedWith == NULL, "invariant") ; | |
4113 } else { | |
4114 // Do this the hard way -- materialize a new Parker.. | |
4115 // In rare cases an allocating thread might detach | |
4116 // a long list -- installing null into FreeList --and | |
4117 // then stall. Another thread calling Allocate() would see | |
4118 // FreeList == null and then invoke the ctor. In this case we | |
4119 // end up with more Parkers in circulation than we need, but | |
4120 // the race is rare and the outcome is benign. | |
4121 // Ideally, the # of extant Parkers is equal to the | |
4122 // maximum # of threads that existed at any one time. | |
4123 // Because of the race mentioned above, segments of the | |
4124 // freelist can be transiently inaccessible. At worst | |
4125 // we may end up with the # of Parkers in circulation | |
4126 // slightly above the ideal. | |
4127 p = new Parker() ; | |
4128 } | |
4129 p->AssociatedWith = t ; // Associate p with t | |
4130 p->FreeNext = NULL ; | |
4131 return p ; | |
4132 } | |
4133 | |
4134 | |
4135 void Parker::Release (Parker * p) { | |
4136 if (p == NULL) return ; | |
4137 guarantee (p->AssociatedWith != NULL, "invariant") ; | |
4138 guarantee (p->FreeNext == NULL , "invariant") ; | |
4139 p->AssociatedWith = NULL ; | |
4140 for (;;) { | |
4141 // Push p onto FreeList | |
4142 Parker * List = FreeList ; | |
4143 p->FreeNext = List ; | |
4144 if (Atomic::cmpxchg_ptr (p, &FreeList, List) == List) break ; | |
4145 } | |
4146 } | |
4147 | |
4148 void Threads::verify() { | |
4149 ALL_JAVA_THREADS(p) { | |
4150 p->verify(); | |
4151 } | |
4152 VMThread* thread = VMThread::vm_thread(); | |
4153 if (thread != NULL) thread->verify(); | |
4154 } |