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