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