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