Mercurial > hg > graal-jvmci-8
annotate src/share/vm/runtime/safepoint.cpp @ 8854:754c24457b20
7112912: Message "Error occurred during initialization of VM" on boxes with lots of RAM
Summary: Ergonomics now also takes available virtual memory into account when deciding for a heap size. The helper method to determine the maximum allocatable memory block now uses the appropriate OS specific calls to retrieve available virtual memory for the java process. In 32 bit environments this method now also searches for the maximum actually reservable amount of memory. Merge previously separate implementations for Linux/BSD/Solaris into a single method.
Reviewed-by: jmasa, tamao
| author | tschatzl |
|---|---|
| date | Wed, 27 Mar 2013 19:21:18 +0100 |
| parents | db9981fd3124 |
| children | 5fc51c1ecdeb cc32ccaaf47f |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
4867
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1538
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1538
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:
1538
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 6162 | 26 #include "classfile/symbolTable.hpp" |
| 1972 | 27 #include "classfile/systemDictionary.hpp" |
| 28 #include "code/codeCache.hpp" | |
| 29 #include "code/icBuffer.hpp" | |
| 30 #include "code/nmethod.hpp" | |
| 31 #include "code/pcDesc.hpp" | |
| 32 #include "code/scopeDesc.hpp" | |
| 33 #include "gc_interface/collectedHeap.hpp" | |
| 34 #include "interpreter/interpreter.hpp" | |
| 35 #include "memory/resourceArea.hpp" | |
| 36 #include "memory/universe.inline.hpp" | |
| 37 #include "oops/oop.inline.hpp" | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
38 #include "oops/symbol.hpp" |
| 1972 | 39 #include "runtime/compilationPolicy.hpp" |
| 40 #include "runtime/deoptimization.hpp" | |
| 41 #include "runtime/frame.inline.hpp" | |
| 42 #include "runtime/interfaceSupport.hpp" | |
| 43 #include "runtime/mutexLocker.hpp" | |
| 44 #include "runtime/osThread.hpp" | |
| 45 #include "runtime/safepoint.hpp" | |
| 46 #include "runtime/signature.hpp" | |
| 47 #include "runtime/stubCodeGenerator.hpp" | |
| 48 #include "runtime/stubRoutines.hpp" | |
| 49 #include "runtime/sweeper.hpp" | |
| 50 #include "runtime/synchronizer.hpp" | |
|
7180
f34d701e952e
8003935: Simplify the needed includes for using Thread::current()
stefank
parents:
6197
diff
changeset
|
51 #include "runtime/thread.inline.hpp" |
| 6197 | 52 #include "services/memTracker.hpp" |
| 1972 | 53 #include "services/runtimeService.hpp" |
| 54 #include "utilities/events.hpp" | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7180
diff
changeset
|
55 #include "utilities/macros.hpp" |
| 1972 | 56 #ifdef TARGET_ARCH_x86 |
| 57 # include "nativeInst_x86.hpp" | |
| 58 # include "vmreg_x86.inline.hpp" | |
| 59 #endif | |
| 60 #ifdef TARGET_ARCH_sparc | |
| 61 # include "nativeInst_sparc.hpp" | |
| 62 # include "vmreg_sparc.inline.hpp" | |
| 63 #endif | |
| 64 #ifdef TARGET_ARCH_zero | |
| 65 # include "nativeInst_zero.hpp" | |
| 66 # include "vmreg_zero.inline.hpp" | |
| 67 #endif | |
|
2192
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
68 #ifdef TARGET_ARCH_arm |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
69 # include "nativeInst_arm.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
70 # include "vmreg_arm.inline.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
71 #endif |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
72 #ifdef TARGET_ARCH_ppc |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
73 # include "nativeInst_ppc.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
74 # include "vmreg_ppc.inline.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
75 #endif |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7180
diff
changeset
|
76 #if INCLUDE_ALL_GCS |
| 1972 | 77 #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepThread.hpp" |
| 78 #include "gc_implementation/shared/concurrentGCThread.hpp" | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7180
diff
changeset
|
79 #endif // INCLUDE_ALL_GCS |
| 1972 | 80 #ifdef COMPILER1 |
| 81 #include "c1/c1_globals.hpp" | |
| 82 #endif | |
| 0 | 83 |
| 84 // -------------------------------------------------------------------------------------------------- | |
| 85 // Implementation of Safepoint begin/end | |
| 86 | |
| 87 SafepointSynchronize::SynchronizeState volatile SafepointSynchronize::_state = SafepointSynchronize::_not_synchronized; | |
| 88 volatile int SafepointSynchronize::_waiting_to_block = 0; | |
| 89 volatile int SafepointSynchronize::_safepoint_counter = 0; | |
|
4867
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
90 int SafepointSynchronize::_current_jni_active_count = 0; |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
91 long SafepointSynchronize::_end_of_last_safepoint = 0; |
| 0 | 92 static volatile int PageArmed = 0 ; // safepoint polling page is RO|RW vs PROT_NONE |
| 93 static volatile int TryingToBlock = 0 ; // proximate value -- for advisory use only | |
| 94 static bool timeout_error_printed = false; | |
| 95 | |
| 96 // Roll all threads forward to a safepoint and suspend them all | |
| 97 void SafepointSynchronize::begin() { | |
| 98 | |
| 99 Thread* myThread = Thread::current(); | |
| 100 assert(myThread->is_VM_thread(), "Only VM thread may execute a safepoint"); | |
| 101 | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
102 if (PrintSafepointStatistics || PrintSafepointStatisticsTimeout > 0) { |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
103 _safepoint_begin_time = os::javaTimeNanos(); |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
104 _ts_of_current_safepoint = tty->time_stamp().seconds(); |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
105 } |
| 0 | 106 |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7180
diff
changeset
|
107 #if INCLUDE_ALL_GCS |
| 0 | 108 if (UseConcMarkSweepGC) { |
| 109 // In the future we should investigate whether CMS can use the | |
| 110 // more-general mechanism below. DLD (01/05). | |
| 111 ConcurrentMarkSweepThread::synchronize(false); | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
628
diff
changeset
|
112 } else if (UseG1GC) { |
| 0 | 113 ConcurrentGCThread::safepoint_synchronize(); |
| 114 } | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7180
diff
changeset
|
115 #endif // INCLUDE_ALL_GCS |
| 0 | 116 |
| 117 // By getting the Threads_lock, we assure that no threads are about to start or | |
| 118 // exit. It is released again in SafepointSynchronize::end(). | |
| 119 Threads_lock->lock(); | |
| 120 | |
| 121 assert( _state == _not_synchronized, "trying to safepoint synchronize with wrong state"); | |
| 122 | |
| 123 int nof_threads = Threads::number_of_threads(); | |
| 124 | |
| 125 if (TraceSafepoint) { | |
| 126 tty->print_cr("Safepoint synchronization initiated. (%d)", nof_threads); | |
| 127 } | |
| 128 | |
| 129 RuntimeService::record_safepoint_begin(); | |
| 130 | |
| 131 MutexLocker mu(Safepoint_lock); | |
| 132 | |
|
4867
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
133 // Reset the count of active JNI critical threads |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
134 _current_jni_active_count = 0; |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
135 |
| 0 | 136 // Set number of threads to wait for, before we initiate the callbacks |
| 137 _waiting_to_block = nof_threads; | |
| 138 TryingToBlock = 0 ; | |
| 139 int still_running = nof_threads; | |
| 140 | |
| 141 // Save the starting time, so that it can be compared to see if this has taken | |
| 142 // too long to complete. | |
| 143 jlong safepoint_limit_time; | |
| 144 timeout_error_printed = false; | |
| 145 | |
| 1003 | 146 // PrintSafepointStatisticsTimeout can be specified separately. When |
| 147 // specified, PrintSafepointStatistics will be set to true in | |
| 148 // deferred_initialize_stat method. The initialization has to be done | |
| 149 // early enough to avoid any races. See bug 6880029 for details. | |
| 150 if (PrintSafepointStatistics || PrintSafepointStatisticsTimeout > 0) { | |
| 151 deferred_initialize_stat(); | |
| 152 } | |
| 153 | |
| 0 | 154 // Begin the process of bringing the system to a safepoint. |
| 155 // Java threads can be in several different states and are | |
| 156 // stopped by different mechanisms: | |
| 157 // | |
| 158 // 1. Running interpreted | |
| 159 // The interpeter dispatch table is changed to force it to | |
| 160 // check for a safepoint condition between bytecodes. | |
| 161 // 2. Running in native code | |
| 162 // When returning from the native code, a Java thread must check | |
| 163 // the safepoint _state to see if we must block. If the | |
| 164 // VM thread sees a Java thread in native, it does | |
| 165 // not wait for this thread to block. The order of the memory | |
| 166 // writes and reads of both the safepoint state and the Java | |
| 167 // threads state is critical. In order to guarantee that the | |
| 168 // memory writes are serialized with respect to each other, | |
| 169 // the VM thread issues a memory barrier instruction | |
| 170 // (on MP systems). In order to avoid the overhead of issuing | |
| 171 // a memory barrier for each Java thread making native calls, each Java | |
| 172 // thread performs a write to a single memory page after changing | |
| 173 // the thread state. The VM thread performs a sequence of | |
| 174 // mprotect OS calls which forces all previous writes from all | |
| 175 // Java threads to be serialized. This is done in the | |
| 176 // os::serialize_thread_states() call. This has proven to be | |
| 177 // much more efficient than executing a membar instruction | |
| 178 // on every call to native code. | |
| 179 // 3. Running compiled Code | |
| 180 // Compiled code reads a global (Safepoint Polling) page that | |
| 181 // is set to fault if we are trying to get to a safepoint. | |
| 182 // 4. Blocked | |
| 183 // A thread which is blocked will not be allowed to return from the | |
| 184 // block condition until the safepoint operation is complete. | |
| 185 // 5. In VM or Transitioning between states | |
| 186 // If a Java thread is currently running in the VM or transitioning | |
| 187 // between states, the safepointing code will wait for the thread to | |
| 188 // block itself when it attempts transitions to a new state. | |
| 189 // | |
| 190 _state = _synchronizing; | |
| 191 OrderAccess::fence(); | |
| 192 | |
| 193 // Flush all thread states to memory | |
| 194 if (!UseMembar) { | |
| 195 os::serialize_thread_states(); | |
| 196 } | |
| 197 | |
| 198 // Make interpreter safepoint aware | |
| 199 Interpreter::notice_safepoints(); | |
| 200 | |
| 201 if (UseCompilerSafepoints && DeferPollingPageLoopCount < 0) { | |
| 202 // Make polling safepoint aware | |
| 203 guarantee (PageArmed == 0, "invariant") ; | |
| 204 PageArmed = 1 ; | |
| 205 os::make_polling_page_unreadable(); | |
| 206 } | |
| 207 | |
| 208 // Consider using active_processor_count() ... but that call is expensive. | |
| 209 int ncpus = os::processor_count() ; | |
| 210 | |
| 211 #ifdef ASSERT | |
| 212 for (JavaThread *cur = Threads::first(); cur != NULL; cur = cur->next()) { | |
| 213 assert(cur->safepoint_state()->is_running(), "Illegal initial state"); | |
|
5928
541c4a5e7b88
7150390: JFR test crashed on assert(_jni_lock_count == count) failed: must be equal
never
parents:
4873
diff
changeset
|
214 // Clear the visited flag to ensure that the critical counts are collected properly. |
|
541c4a5e7b88
7150390: JFR test crashed on assert(_jni_lock_count == count) failed: must be equal
never
parents:
4873
diff
changeset
|
215 cur->set_visited_for_critical_count(false); |
| 0 | 216 } |
| 217 #endif // ASSERT | |
| 218 | |
| 219 if (SafepointTimeout) | |
| 220 safepoint_limit_time = os::javaTimeNanos() + (jlong)SafepointTimeoutDelay * MICROUNITS; | |
| 221 | |
| 222 // Iterate through all threads until it have been determined how to stop them all at a safepoint | |
| 223 unsigned int iterations = 0; | |
| 224 int steps = 0 ; | |
| 225 while(still_running > 0) { | |
| 226 for (JavaThread *cur = Threads::first(); cur != NULL; cur = cur->next()) { | |
| 227 assert(!cur->is_ConcurrentGC_thread(), "A concurrent GC thread is unexpectly being suspended"); | |
| 228 ThreadSafepointState *cur_state = cur->safepoint_state(); | |
| 229 if (cur_state->is_running()) { | |
| 230 cur_state->examine_state_of_thread(); | |
| 231 if (!cur_state->is_running()) { | |
| 232 still_running--; | |
| 233 // consider adjusting steps downward: | |
| 234 // steps = 0 | |
| 235 // steps -= NNN | |
| 236 // steps >>= 1 | |
| 237 // steps = MIN(steps, 2000-100) | |
| 238 // if (iterations != 0) steps -= NNN | |
| 239 } | |
| 240 if (TraceSafepoint && Verbose) cur_state->print(); | |
| 241 } | |
| 242 } | |
| 243 | |
| 1003 | 244 if (PrintSafepointStatistics && iterations == 0) { |
| 0 | 245 begin_statistics(nof_threads, still_running); |
| 246 } | |
| 247 | |
| 248 if (still_running > 0) { | |
| 249 // Check for if it takes to long | |
| 250 if (SafepointTimeout && safepoint_limit_time < os::javaTimeNanos()) { | |
| 251 print_safepoint_timeout(_spinning_timeout); | |
| 252 } | |
| 253 | |
| 254 // Spin to avoid context switching. | |
| 255 // There's a tension between allowing the mutators to run (and rendezvous) | |
| 256 // vs spinning. As the VM thread spins, wasting cycles, it consumes CPU that | |
| 257 // a mutator might otherwise use profitably to reach a safepoint. Excessive | |
| 258 // spinning by the VM thread on a saturated system can increase rendezvous latency. | |
| 259 // Blocking or yielding incur their own penalties in the form of context switching | |
| 260 // and the resultant loss of $ residency. | |
| 261 // | |
| 262 // Further complicating matters is that yield() does not work as naively expected | |
| 263 // on many platforms -- yield() does not guarantee that any other ready threads | |
| 264 // will run. As such we revert yield_all() after some number of iterations. | |
| 265 // Yield_all() is implemented as a short unconditional sleep on some platforms. | |
| 266 // Typical operating systems round a "short" sleep period up to 10 msecs, so sleeping | |
| 267 // can actually increase the time it takes the VM thread to detect that a system-wide | |
| 268 // stop-the-world safepoint has been reached. In a pathological scenario such as that | |
| 269 // described in CR6415670 the VMthread may sleep just before the mutator(s) become safe. | |
| 270 // In that case the mutators will be stalled waiting for the safepoint to complete and the | |
| 271 // the VMthread will be sleeping, waiting for the mutators to rendezvous. The VMthread | |
| 272 // will eventually wake up and detect that all mutators are safe, at which point | |
| 273 // we'll again make progress. | |
| 274 // | |
| 275 // Beware too that that the VMThread typically runs at elevated priority. | |
| 276 // Its default priority is higher than the default mutator priority. | |
| 277 // Obviously, this complicates spinning. | |
| 278 // | |
| 279 // Note too that on Windows XP SwitchThreadTo() has quite different behavior than Sleep(0). | |
| 280 // Sleep(0) will _not yield to lower priority threads, while SwitchThreadTo() will. | |
| 281 // | |
| 282 // See the comments in synchronizer.cpp for additional remarks on spinning. | |
| 283 // | |
| 284 // In the future we might: | |
| 285 // 1. Modify the safepoint scheme to avoid potentally unbounded spinning. | |
| 286 // This is tricky as the path used by a thread exiting the JVM (say on | |
| 287 // on JNI call-out) simply stores into its state field. The burden | |
| 288 // is placed on the VM thread, which must poll (spin). | |
| 289 // 2. Find something useful to do while spinning. If the safepoint is GC-related | |
| 290 // we might aggressively scan the stacks of threads that are already safe. | |
| 291 // 3. Use Solaris schedctl to examine the state of the still-running mutators. | |
| 292 // If all the mutators are ONPROC there's no reason to sleep or yield. | |
| 293 // 4. YieldTo() any still-running mutators that are ready but OFFPROC. | |
| 294 // 5. Check system saturation. If the system is not fully saturated then | |
| 295 // simply spin and avoid sleep/yield. | |
| 296 // 6. As still-running mutators rendezvous they could unpark the sleeping | |
| 297 // VMthread. This works well for still-running mutators that become | |
| 298 // safe. The VMthread must still poll for mutators that call-out. | |
| 299 // 7. Drive the policy on time-since-begin instead of iterations. | |
| 300 // 8. Consider making the spin duration a function of the # of CPUs: | |
| 301 // Spin = (((ncpus-1) * M) + K) + F(still_running) | |
| 302 // Alternately, instead of counting iterations of the outer loop | |
| 303 // we could count the # of threads visited in the inner loop, above. | |
| 304 // 9. On windows consider using the return value from SwitchThreadTo() | |
| 305 // to drive subsequent spin/SwitchThreadTo()/Sleep(N) decisions. | |
| 306 | |
| 307 if (UseCompilerSafepoints && int(iterations) == DeferPollingPageLoopCount) { | |
| 308 guarantee (PageArmed == 0, "invariant") ; | |
| 309 PageArmed = 1 ; | |
| 310 os::make_polling_page_unreadable(); | |
| 311 } | |
| 312 | |
| 313 // Instead of (ncpus > 1) consider either (still_running < (ncpus + EPSILON)) or | |
| 314 // ((still_running + _waiting_to_block - TryingToBlock)) < ncpus) | |
| 315 ++steps ; | |
| 316 if (ncpus > 1 && steps < SafepointSpinBeforeYield) { | |
| 317 SpinPause() ; // MP-Polite spin | |
| 318 } else | |
| 319 if (steps < DeferThrSuspendLoopCount) { | |
| 320 os::NakedYield() ; | |
| 321 } else { | |
| 322 os::yield_all(steps) ; | |
| 323 // Alternately, the VM thread could transiently depress its scheduling priority or | |
| 324 // transiently increase the priority of the tardy mutator(s). | |
| 325 } | |
| 326 | |
| 327 iterations ++ ; | |
| 328 } | |
| 329 assert(iterations < (uint)max_jint, "We have been iterating in the safepoint loop too long"); | |
| 330 } | |
| 331 assert(still_running == 0, "sanity check"); | |
| 332 | |
| 333 if (PrintSafepointStatistics) { | |
| 334 update_statistics_on_spin_end(); | |
| 335 } | |
| 336 | |
| 337 // wait until all threads are stopped | |
| 338 while (_waiting_to_block > 0) { | |
| 339 if (TraceSafepoint) tty->print_cr("Waiting for %d thread(s) to block", _waiting_to_block); | |
| 340 if (!SafepointTimeout || timeout_error_printed) { | |
| 341 Safepoint_lock->wait(true); // true, means with no safepoint checks | |
| 342 } else { | |
| 343 // Compute remaining time | |
| 344 jlong remaining_time = safepoint_limit_time - os::javaTimeNanos(); | |
| 345 | |
| 346 // If there is no remaining time, then there is an error | |
| 347 if (remaining_time < 0 || Safepoint_lock->wait(true, remaining_time / MICROUNITS)) { | |
| 348 print_safepoint_timeout(_blocking_timeout); | |
| 349 } | |
| 350 } | |
| 351 } | |
| 352 assert(_waiting_to_block == 0, "sanity check"); | |
| 353 | |
| 354 #ifndef PRODUCT | |
| 355 if (SafepointTimeout) { | |
| 356 jlong current_time = os::javaTimeNanos(); | |
| 357 if (safepoint_limit_time < current_time) { | |
| 358 tty->print_cr("# SafepointSynchronize: Finished after " | |
| 359 INT64_FORMAT_W(6) " ms", | |
| 360 ((current_time - safepoint_limit_time) / MICROUNITS + | |
| 361 SafepointTimeoutDelay)); | |
| 362 } | |
| 363 } | |
| 364 #endif | |
| 365 | |
| 366 assert((_safepoint_counter & 0x1) == 0, "must be even"); | |
| 367 assert(Threads_lock->owned_by_self(), "must hold Threads_lock"); | |
| 368 _safepoint_counter ++; | |
| 369 | |
| 370 // Record state | |
| 371 _state = _synchronized; | |
| 372 | |
| 373 OrderAccess::fence(); | |
| 374 | |
|
5928
541c4a5e7b88
7150390: JFR test crashed on assert(_jni_lock_count == count) failed: must be equal
never
parents:
4873
diff
changeset
|
375 #ifdef ASSERT |
|
541c4a5e7b88
7150390: JFR test crashed on assert(_jni_lock_count == count) failed: must be equal
never
parents:
4873
diff
changeset
|
376 for (JavaThread *cur = Threads::first(); cur != NULL; cur = cur->next()) { |
|
541c4a5e7b88
7150390: JFR test crashed on assert(_jni_lock_count == count) failed: must be equal
never
parents:
4873
diff
changeset
|
377 // make sure all the threads were visited |
|
541c4a5e7b88
7150390: JFR test crashed on assert(_jni_lock_count == count) failed: must be equal
never
parents:
4873
diff
changeset
|
378 assert(cur->was_visited_for_critical_count(), "missed a thread"); |
|
541c4a5e7b88
7150390: JFR test crashed on assert(_jni_lock_count == count) failed: must be equal
never
parents:
4873
diff
changeset
|
379 } |
|
541c4a5e7b88
7150390: JFR test crashed on assert(_jni_lock_count == count) failed: must be equal
never
parents:
4873
diff
changeset
|
380 #endif // ASSERT |
|
541c4a5e7b88
7150390: JFR test crashed on assert(_jni_lock_count == count) failed: must be equal
never
parents:
4873
diff
changeset
|
381 |
|
4867
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
382 // Update the count of active JNI critical regions |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
383 GC_locker::set_jni_lock_count(_current_jni_active_count); |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
384 |
| 0 | 385 if (TraceSafepoint) { |
| 386 VM_Operation *op = VMThread::vm_operation(); | |
| 387 tty->print_cr("Entering safepoint region: %s", (op != NULL) ? op->name() : "no vm operation"); | |
| 388 } | |
| 389 | |
| 390 RuntimeService::record_safepoint_synchronized(); | |
| 391 if (PrintSafepointStatistics) { | |
| 392 update_statistics_on_sync_end(os::javaTimeNanos()); | |
| 393 } | |
| 394 | |
| 395 // Call stuff that needs to be run when a safepoint is just about to be completed | |
| 396 do_cleanup_tasks(); | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
397 |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
398 if (PrintSafepointStatistics) { |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
399 // Record how much time spend on the above cleanup tasks |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
400 update_statistics_on_cleanup_end(os::javaTimeNanos()); |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
401 } |
| 0 | 402 } |
| 403 | |
| 404 // Wake up all threads, so they are ready to resume execution after the safepoint | |
| 405 // operation has been carried out | |
| 406 void SafepointSynchronize::end() { | |
| 407 | |
| 408 assert(Threads_lock->owned_by_self(), "must hold Threads_lock"); | |
| 409 assert((_safepoint_counter & 0x1) == 1, "must be odd"); | |
| 410 _safepoint_counter ++; | |
| 411 // memory fence isn't required here since an odd _safepoint_counter | |
| 412 // value can do no harm and a fence is issued below anyway. | |
| 413 | |
| 414 DEBUG_ONLY(Thread* myThread = Thread::current();) | |
| 415 assert(myThread->is_VM_thread(), "Only VM thread can execute a safepoint"); | |
| 416 | |
| 417 if (PrintSafepointStatistics) { | |
| 418 end_statistics(os::javaTimeNanos()); | |
| 419 } | |
| 420 | |
| 421 #ifdef ASSERT | |
| 422 // A pending_exception cannot be installed during a safepoint. The threads | |
| 423 // may install an async exception after they come back from a safepoint into | |
| 424 // pending_exception after they unblock. But that should happen later. | |
| 425 for(JavaThread *cur = Threads::first(); cur; cur = cur->next()) { | |
| 426 assert (!(cur->has_pending_exception() && | |
| 427 cur->safepoint_state()->is_at_poll_safepoint()), | |
| 428 "safepoint installed a pending exception"); | |
| 429 } | |
| 430 #endif // ASSERT | |
| 431 | |
| 432 if (PageArmed) { | |
| 433 // Make polling safepoint aware | |
| 434 os::make_polling_page_readable(); | |
| 435 PageArmed = 0 ; | |
| 436 } | |
| 437 | |
| 438 // Remove safepoint check from interpreter | |
| 439 Interpreter::ignore_safepoints(); | |
| 440 | |
| 441 { | |
| 442 MutexLocker mu(Safepoint_lock); | |
| 443 | |
| 444 assert(_state == _synchronized, "must be synchronized before ending safepoint synchronization"); | |
| 445 | |
| 446 // Set to not synchronized, so the threads will not go into the signal_thread_blocked method | |
| 447 // when they get restarted. | |
| 448 _state = _not_synchronized; | |
| 449 OrderAccess::fence(); | |
| 450 | |
| 451 if (TraceSafepoint) { | |
| 452 tty->print_cr("Leaving safepoint region"); | |
| 453 } | |
| 454 | |
| 455 // Start suspended threads | |
| 456 for(JavaThread *current = Threads::first(); current; current = current->next()) { | |
| 605 | 457 // A problem occurring on Solaris is when attempting to restart threads |
| 0 | 458 // the first #cpus - 1 go well, but then the VMThread is preempted when we get |
| 459 // to the next one (since it has been running the longest). We then have | |
| 460 // to wait for a cpu to become available before we can continue restarting | |
| 461 // threads. | |
| 462 // FIXME: This causes the performance of the VM to degrade when active and with | |
| 463 // large numbers of threads. Apparently this is due to the synchronous nature | |
| 464 // of suspending threads. | |
| 465 // | |
| 466 // TODO-FIXME: the comments above are vestigial and no longer apply. | |
| 467 // Furthermore, using solaris' schedctl in this particular context confers no benefit | |
| 468 if (VMThreadHintNoPreempt) { | |
| 469 os::hint_no_preempt(); | |
| 470 } | |
| 471 ThreadSafepointState* cur_state = current->safepoint_state(); | |
| 472 assert(cur_state->type() != ThreadSafepointState::_running, "Thread not suspended at safepoint"); | |
| 473 cur_state->restart(); | |
| 474 assert(cur_state->is_running(), "safepoint state has not been reset"); | |
| 475 } | |
| 476 | |
| 477 RuntimeService::record_safepoint_end(); | |
| 478 | |
| 479 // Release threads lock, so threads can be created/destroyed again. It will also starts all threads | |
| 480 // blocked in signal_thread_blocked | |
| 481 Threads_lock->unlock(); | |
| 482 | |
| 483 } | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7180
diff
changeset
|
484 #if INCLUDE_ALL_GCS |
| 0 | 485 // If there are any concurrent GC threads resume them. |
| 486 if (UseConcMarkSweepGC) { | |
| 487 ConcurrentMarkSweepThread::desynchronize(false); | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
628
diff
changeset
|
488 } else if (UseG1GC) { |
| 0 | 489 ConcurrentGCThread::safepoint_desynchronize(); |
| 490 } | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7180
diff
changeset
|
491 #endif // INCLUDE_ALL_GCS |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
492 // record this time so VMThread can keep track how much time has elasped |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
493 // since last safepoint. |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
494 _end_of_last_safepoint = os::javaTimeMillis(); |
| 0 | 495 } |
| 496 | |
| 497 bool SafepointSynchronize::is_cleanup_needed() { | |
| 498 // Need a safepoint if some inline cache buffers is non-empty | |
| 499 if (!InlineCacheBuffer::is_empty()) return true; | |
| 500 return false; | |
| 501 } | |
| 502 | |
| 503 | |
| 504 | |
| 505 // Various cleaning tasks that should be done periodically at safepoints | |
| 506 void SafepointSynchronize::do_cleanup_tasks() { | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
507 { |
|
1321
0f6600cee529
6934758: Expose the break down of clean up task time during safepoint.
xlu
parents:
1291
diff
changeset
|
508 TraceTime t1("deflating idle monitors", TraceSafepointCleanupTime); |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
509 ObjectSynchronizer::deflate_idle_monitors(); |
| 0 | 510 } |
| 511 | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
512 { |
|
1321
0f6600cee529
6934758: Expose the break down of clean up task time during safepoint.
xlu
parents:
1291
diff
changeset
|
513 TraceTime t2("updating inline caches", TraceSafepointCleanupTime); |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
514 InlineCacheBuffer::update_inline_caches(); |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
515 } |
| 1783 | 516 { |
| 517 TraceTime t3("compilation policy safepoint handler", TraceSafepointCleanupTime); | |
| 518 CompilationPolicy::policy()->do_safepoint_work(); | |
| 0 | 519 } |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
520 |
| 6162 | 521 { |
| 522 TraceTime t4("sweeping nmethods", TraceSafepointCleanupTime); | |
| 523 NMethodSweeper::scan_stacks(); | |
| 524 } | |
| 525 | |
| 526 if (SymbolTable::needs_rehashing()) { | |
| 527 TraceTime t5("rehashing symbol table", TraceSafepointCleanupTime); | |
| 528 SymbolTable::rehash_table(); | |
| 529 } | |
| 530 | |
| 531 if (StringTable::needs_rehashing()) { | |
| 532 TraceTime t6("rehashing string table", TraceSafepointCleanupTime); | |
| 533 StringTable::rehash_table(); | |
| 534 } | |
|
3767
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
2426
diff
changeset
|
535 |
|
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
2426
diff
changeset
|
536 // rotate log files? |
|
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
2426
diff
changeset
|
537 if (UseGCLogFileRotation) { |
|
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
2426
diff
changeset
|
538 gclog_or_tty->rotate_log(); |
|
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
2426
diff
changeset
|
539 } |
| 6197 | 540 |
| 541 if (MemTracker::is_on()) { | |
| 542 MemTracker::sync(); | |
| 543 } | |
| 0 | 544 } |
| 545 | |
| 546 | |
| 547 bool SafepointSynchronize::safepoint_safe(JavaThread *thread, JavaThreadState state) { | |
| 548 switch(state) { | |
| 549 case _thread_in_native: | |
| 550 // native threads are safe if they have no java stack or have walkable stack | |
| 551 return !thread->has_last_Java_frame() || thread->frame_anchor()->walkable(); | |
| 552 | |
| 553 // blocked threads should have already have walkable stack | |
| 554 case _thread_blocked: | |
| 555 assert(!thread->has_last_Java_frame() || thread->frame_anchor()->walkable(), "blocked and not walkable"); | |
| 556 return true; | |
| 557 | |
| 558 default: | |
| 559 return false; | |
| 560 } | |
| 561 } | |
| 562 | |
| 563 | |
|
4873
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
564 // See if the thread is running inside a lazy critical native and |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
565 // update the thread critical count if so. Also set a suspend flag to |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
566 // cause the native wrapper to return into the JVM to do the unlock |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
567 // once the native finishes. |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
568 void SafepointSynchronize::check_for_lazy_critical_native(JavaThread *thread, JavaThreadState state) { |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
569 if (state == _thread_in_native && |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
570 thread->has_last_Java_frame() && |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
571 thread->frame_anchor()->walkable()) { |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
572 // This thread might be in a critical native nmethod so look at |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
573 // the top of the stack and increment the critical count if it |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
574 // is. |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
575 frame wrapper_frame = thread->last_frame(); |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
576 CodeBlob* stub_cb = wrapper_frame.cb(); |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
577 if (stub_cb != NULL && |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
578 stub_cb->is_nmethod() && |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
579 stub_cb->as_nmethod_or_null()->is_lazy_critical_native()) { |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
580 // A thread could potentially be in a critical native across |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
581 // more than one safepoint, so only update the critical state on |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
582 // the first one. When it returns it will perform the unlock. |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
583 if (!thread->do_critical_native_unlock()) { |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
584 #ifdef ASSERT |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
585 if (!thread->in_critical()) { |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
586 GC_locker::increment_debug_jni_lock_count(); |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
587 } |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
588 #endif |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
589 thread->enter_critical(); |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
590 // Make sure the native wrapper calls back on return to |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
591 // perform the needed critical unlock. |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
592 thread->set_critical_native_unlock(); |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
593 } |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
594 } |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
595 } |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
596 } |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
597 |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
598 |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
599 |
| 0 | 600 // ------------------------------------------------------------------------------------------------------- |
| 601 // Implementation of Safepoint callback point | |
| 602 | |
| 603 void SafepointSynchronize::block(JavaThread *thread) { | |
| 604 assert(thread != NULL, "thread must be set"); | |
| 605 assert(thread->is_Java_thread(), "not a Java thread"); | |
| 606 | |
| 607 // Threads shouldn't block if they are in the middle of printing, but... | |
| 608 ttyLocker::break_tty_lock_for_safepoint(os::current_thread_id()); | |
| 609 | |
| 610 // Only bail from the block() call if the thread is gone from the | |
| 611 // thread list; starting to exit should still block. | |
| 612 if (thread->is_terminated()) { | |
| 613 // block current thread if we come here from native code when VM is gone | |
| 614 thread->block_if_vm_exited(); | |
| 615 | |
| 616 // otherwise do nothing | |
| 617 return; | |
| 618 } | |
| 619 | |
| 620 JavaThreadState state = thread->thread_state(); | |
| 621 thread->frame_anchor()->make_walkable(thread); | |
| 622 | |
| 623 // Check that we have a valid thread_state at this point | |
| 624 switch(state) { | |
| 625 case _thread_in_vm_trans: | |
| 626 case _thread_in_Java: // From compiled code | |
| 627 | |
| 628 // We are highly likely to block on the Safepoint_lock. In order to avoid blocking in this case, | |
| 629 // we pretend we are still in the VM. | |
| 630 thread->set_thread_state(_thread_in_vm); | |
| 631 | |
| 632 if (is_synchronizing()) { | |
| 633 Atomic::inc (&TryingToBlock) ; | |
| 634 } | |
| 635 | |
| 636 // We will always be holding the Safepoint_lock when we are examine the state | |
| 637 // of a thread. Hence, the instructions between the Safepoint_lock->lock() and | |
| 638 // Safepoint_lock->unlock() are happening atomic with regards to the safepoint code | |
| 639 Safepoint_lock->lock_without_safepoint_check(); | |
| 640 if (is_synchronizing()) { | |
| 641 // Decrement the number of threads to wait for and signal vm thread | |
| 642 assert(_waiting_to_block > 0, "sanity check"); | |
| 643 _waiting_to_block--; | |
| 644 thread->safepoint_state()->set_has_called_back(true); | |
| 645 | |
|
5928
541c4a5e7b88
7150390: JFR test crashed on assert(_jni_lock_count == count) failed: must be equal
never
parents:
4873
diff
changeset
|
646 DEBUG_ONLY(thread->set_visited_for_critical_count(true)); |
|
4867
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
647 if (thread->in_critical()) { |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
648 // Notice that this thread is in a critical section |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
649 increment_jni_active_count(); |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
650 } |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
651 |
| 0 | 652 // Consider (_waiting_to_block < 2) to pipeline the wakeup of the VM thread |
| 653 if (_waiting_to_block == 0) { | |
| 654 Safepoint_lock->notify_all(); | |
| 655 } | |
| 656 } | |
| 657 | |
| 658 // We transition the thread to state _thread_blocked here, but | |
| 659 // we can't do our usual check for external suspension and then | |
| 660 // self-suspend after the lock_without_safepoint_check() call | |
| 661 // below because we are often called during transitions while | |
| 662 // we hold different locks. That would leave us suspended while | |
| 663 // holding a resource which results in deadlocks. | |
| 664 thread->set_thread_state(_thread_blocked); | |
| 665 Safepoint_lock->unlock(); | |
| 666 | |
| 667 // We now try to acquire the threads lock. Since this lock is hold by the VM thread during | |
| 668 // the entire safepoint, the threads will all line up here during the safepoint. | |
| 669 Threads_lock->lock_without_safepoint_check(); | |
| 670 // restore original state. This is important if the thread comes from compiled code, so it | |
| 671 // will continue to execute with the _thread_in_Java state. | |
| 672 thread->set_thread_state(state); | |
| 673 Threads_lock->unlock(); | |
| 674 break; | |
| 675 | |
| 676 case _thread_in_native_trans: | |
| 677 case _thread_blocked_trans: | |
| 678 case _thread_new_trans: | |
| 679 if (thread->safepoint_state()->type() == ThreadSafepointState::_call_back) { | |
| 680 thread->print_thread_state(); | |
| 681 fatal("Deadlock in safepoint code. " | |
| 682 "Should have called back to the VM before blocking."); | |
| 683 } | |
| 684 | |
| 685 // We transition the thread to state _thread_blocked here, but | |
| 686 // we can't do our usual check for external suspension and then | |
| 687 // self-suspend after the lock_without_safepoint_check() call | |
| 688 // below because we are often called during transitions while | |
| 689 // we hold different locks. That would leave us suspended while | |
| 690 // holding a resource which results in deadlocks. | |
| 691 thread->set_thread_state(_thread_blocked); | |
| 692 | |
| 693 // It is not safe to suspend a thread if we discover it is in _thread_in_native_trans. Hence, | |
| 694 // the safepoint code might still be waiting for it to block. We need to change the state here, | |
| 695 // so it can see that it is at a safepoint. | |
| 696 | |
| 697 // Block until the safepoint operation is completed. | |
| 698 Threads_lock->lock_without_safepoint_check(); | |
| 699 | |
| 700 // Restore state | |
| 701 thread->set_thread_state(state); | |
| 702 | |
| 703 Threads_lock->unlock(); | |
| 704 break; | |
| 705 | |
| 706 default: | |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1321
diff
changeset
|
707 fatal(err_msg("Illegal threadstate encountered: %d", state)); |
| 0 | 708 } |
| 709 | |
| 710 // Check for pending. async. exceptions or suspends - except if the | |
| 711 // thread was blocked inside the VM. has_special_runtime_exit_condition() | |
| 712 // is called last since it grabs a lock and we only want to do that when | |
| 713 // we must. | |
| 714 // | |
| 715 // Note: we never deliver an async exception at a polling point as the | |
| 716 // compiler may not have an exception handler for it. The polling | |
| 717 // code will notice the async and deoptimize and the exception will | |
| 718 // be delivered. (Polling at a return point is ok though). Sure is | |
| 719 // a lot of bother for a deprecated feature... | |
| 720 // | |
| 721 // We don't deliver an async exception if the thread state is | |
| 722 // _thread_in_native_trans so JNI functions won't be called with | |
| 723 // a surprising pending exception. If the thread state is going back to java, | |
| 724 // async exception is checked in check_special_condition_for_native_trans(). | |
| 725 | |
| 726 if (state != _thread_blocked_trans && | |
| 727 state != _thread_in_vm_trans && | |
| 728 thread->has_special_runtime_exit_condition()) { | |
| 729 thread->handle_special_runtime_exit_condition( | |
| 730 !thread->is_at_poll_safepoint() && (state != _thread_in_native_trans)); | |
| 731 } | |
| 732 } | |
| 733 | |
| 734 // ------------------------------------------------------------------------------------------------------ | |
| 735 // Exception handlers | |
| 736 | |
| 737 #ifndef PRODUCT | |
| 738 #ifdef _LP64 | |
| 739 #define PTR_PAD "" | |
| 740 #else | |
| 741 #define PTR_PAD " " | |
| 742 #endif | |
| 743 | |
| 744 static void print_ptrs(intptr_t oldptr, intptr_t newptr, bool wasoop) { | |
| 745 bool is_oop = newptr ? ((oop)newptr)->is_oop() : false; | |
| 746 tty->print_cr(PTR_FORMAT PTR_PAD " %s %c " PTR_FORMAT PTR_PAD " %s %s", | |
| 747 oldptr, wasoop?"oop":" ", oldptr == newptr ? ' ' : '!', | |
| 748 newptr, is_oop?"oop":" ", (wasoop && !is_oop) ? "STALE" : ((wasoop==false&&is_oop==false&&oldptr !=newptr)?"STOMP":" ")); | |
| 749 } | |
| 750 | |
| 751 static void print_longs(jlong oldptr, jlong newptr, bool wasoop) { | |
| 752 bool is_oop = newptr ? ((oop)(intptr_t)newptr)->is_oop() : false; | |
| 753 tty->print_cr(PTR64_FORMAT " %s %c " PTR64_FORMAT " %s %s", | |
| 754 oldptr, wasoop?"oop":" ", oldptr == newptr ? ' ' : '!', | |
| 755 newptr, is_oop?"oop":" ", (wasoop && !is_oop) ? "STALE" : ((wasoop==false&&is_oop==false&&oldptr !=newptr)?"STOMP":" ")); | |
| 756 } | |
| 757 | |
| 758 #ifdef SPARC | |
| 759 static void print_me(intptr_t *new_sp, intptr_t *old_sp, bool *was_oops) { | |
| 760 #ifdef _LP64 | |
| 761 tty->print_cr("--------+------address-----+------before-----------+-------after----------+"); | |
| 762 const int incr = 1; // Increment to skip a long, in units of intptr_t | |
| 763 #else | |
| 764 tty->print_cr("--------+--address-+------before-----------+-------after----------+"); | |
| 765 const int incr = 2; // Increment to skip a long, in units of intptr_t | |
| 766 #endif | |
| 767 tty->print_cr("---SP---|"); | |
| 768 for( int i=0; i<16; i++ ) { | |
| 769 tty->print("blob %c%d |"PTR_FORMAT" ","LO"[i>>3],i&7,new_sp); print_ptrs(*old_sp++,*new_sp++,*was_oops++); } | |
| 770 tty->print_cr("--------|"); | |
| 771 for( int i1=0; i1<frame::memory_parameter_word_sp_offset-16; i1++ ) { | |
| 772 tty->print("argv pad|"PTR_FORMAT" ",new_sp); print_ptrs(*old_sp++,*new_sp++,*was_oops++); } | |
| 773 tty->print(" pad|"PTR_FORMAT" ",new_sp); print_ptrs(*old_sp++,*new_sp++,*was_oops++); | |
| 774 tty->print_cr("--------|"); | |
| 775 tty->print(" G1 |"PTR_FORMAT" ",new_sp); print_longs(*(jlong*)old_sp,*(jlong*)new_sp,was_oops[incr-1]); old_sp += incr; new_sp += incr; was_oops += incr; | |
| 776 tty->print(" G3 |"PTR_FORMAT" ",new_sp); print_longs(*(jlong*)old_sp,*(jlong*)new_sp,was_oops[incr-1]); old_sp += incr; new_sp += incr; was_oops += incr; | |
| 777 tty->print(" G4 |"PTR_FORMAT" ",new_sp); print_longs(*(jlong*)old_sp,*(jlong*)new_sp,was_oops[incr-1]); old_sp += incr; new_sp += incr; was_oops += incr; | |
| 778 tty->print(" G5 |"PTR_FORMAT" ",new_sp); print_longs(*(jlong*)old_sp,*(jlong*)new_sp,was_oops[incr-1]); old_sp += incr; new_sp += incr; was_oops += incr; | |
| 779 tty->print_cr(" FSR |"PTR_FORMAT" "PTR64_FORMAT" "PTR64_FORMAT,new_sp,*(jlong*)old_sp,*(jlong*)new_sp); | |
| 780 old_sp += incr; new_sp += incr; was_oops += incr; | |
| 781 // Skip the floats | |
| 782 tty->print_cr("--Float-|"PTR_FORMAT,new_sp); | |
| 783 tty->print_cr("---FP---|"); | |
| 784 old_sp += incr*32; new_sp += incr*32; was_oops += incr*32; | |
| 785 for( int i2=0; i2<16; i2++ ) { | |
| 786 tty->print("call %c%d |"PTR_FORMAT" ","LI"[i2>>3],i2&7,new_sp); print_ptrs(*old_sp++,*new_sp++,*was_oops++); } | |
| 787 tty->print_cr(""); | |
| 788 } | |
| 789 #endif // SPARC | |
| 790 #endif // PRODUCT | |
| 791 | |
| 792 | |
| 793 void SafepointSynchronize::handle_polling_page_exception(JavaThread *thread) { | |
| 794 assert(thread->is_Java_thread(), "polling reference encountered by VM thread"); | |
| 795 assert(thread->thread_state() == _thread_in_Java, "should come from Java code"); | |
| 796 assert(SafepointSynchronize::is_synchronizing(), "polling encountered outside safepoint synchronization"); | |
| 797 | |
| 798 // Uncomment this to get some serious before/after printing of the | |
| 799 // Sparc safepoint-blob frame structure. | |
| 800 /* | |
| 801 intptr_t* sp = thread->last_Java_sp(); | |
| 802 intptr_t stack_copy[150]; | |
| 803 for( int i=0; i<150; i++ ) stack_copy[i] = sp[i]; | |
| 804 bool was_oops[150]; | |
| 805 for( int i=0; i<150; i++ ) | |
| 806 was_oops[i] = stack_copy[i] ? ((oop)stack_copy[i])->is_oop() : false; | |
| 807 */ | |
| 808 | |
| 809 if (ShowSafepointMsgs) { | |
| 810 tty->print("handle_polling_page_exception: "); | |
| 811 } | |
| 812 | |
| 813 if (PrintSafepointStatistics) { | |
| 814 inc_page_trap_count(); | |
| 815 } | |
| 816 | |
| 817 ThreadSafepointState* state = thread->safepoint_state(); | |
| 818 | |
| 819 state->handle_polling_page_exception(); | |
| 820 // print_me(sp,stack_copy,was_oops); | |
| 821 } | |
| 822 | |
| 823 | |
| 824 void SafepointSynchronize::print_safepoint_timeout(SafepointTimeoutReason reason) { | |
| 825 if (!timeout_error_printed) { | |
| 826 timeout_error_printed = true; | |
| 827 // Print out the thread infor which didn't reach the safepoint for debugging | |
| 828 // purposes (useful when there are lots of threads in the debugger). | |
| 829 tty->print_cr(""); | |
| 830 tty->print_cr("# SafepointSynchronize::begin: Timeout detected:"); | |
| 831 if (reason == _spinning_timeout) { | |
| 832 tty->print_cr("# SafepointSynchronize::begin: Timed out while spinning to reach a safepoint."); | |
| 833 } else if (reason == _blocking_timeout) { | |
| 834 tty->print_cr("# SafepointSynchronize::begin: Timed out while waiting for threads to stop."); | |
| 835 } | |
| 836 | |
| 837 tty->print_cr("# SafepointSynchronize::begin: Threads which did not reach the safepoint:"); | |
| 838 ThreadSafepointState *cur_state; | |
| 839 ResourceMark rm; | |
| 840 for(JavaThread *cur_thread = Threads::first(); cur_thread; | |
| 841 cur_thread = cur_thread->next()) { | |
| 842 cur_state = cur_thread->safepoint_state(); | |
| 843 | |
| 844 if (cur_thread->thread_state() != _thread_blocked && | |
| 845 ((reason == _spinning_timeout && cur_state->is_running()) || | |
| 846 (reason == _blocking_timeout && !cur_state->has_called_back()))) { | |
| 847 tty->print("# "); | |
| 848 cur_thread->print(); | |
| 849 tty->print_cr(""); | |
| 850 } | |
| 851 } | |
| 852 tty->print_cr("# SafepointSynchronize::begin: (End of list)"); | |
| 853 } | |
| 854 | |
| 855 // To debug the long safepoint, specify both DieOnSafepointTimeout & | |
| 856 // ShowMessageBoxOnError. | |
| 857 if (DieOnSafepointTimeout) { | |
| 858 char msg[1024]; | |
| 859 VM_Operation *op = VMThread::vm_operation(); | |
|
513
2328d1d3f8cf
6781583: Hotspot build fails on linux 64 bit platform with gcc 4.3.2
xlu
parents:
0
diff
changeset
|
860 sprintf(msg, "Safepoint sync time longer than " INTX_FORMAT "ms detected when executing %s.", |
| 0 | 861 SafepointTimeoutDelay, |
| 862 op != NULL ? op->name() : "no vm operation"); | |
| 863 fatal(msg); | |
| 864 } | |
| 865 } | |
| 866 | |
| 867 | |
| 868 // ------------------------------------------------------------------------------------------------------- | |
| 869 // Implementation of ThreadSafepointState | |
| 870 | |
| 871 ThreadSafepointState::ThreadSafepointState(JavaThread *thread) { | |
| 872 _thread = thread; | |
| 873 _type = _running; | |
| 874 _has_called_back = false; | |
| 875 _at_poll_safepoint = false; | |
| 876 } | |
| 877 | |
| 878 void ThreadSafepointState::create(JavaThread *thread) { | |
| 879 ThreadSafepointState *state = new ThreadSafepointState(thread); | |
| 880 thread->set_safepoint_state(state); | |
| 881 } | |
| 882 | |
| 883 void ThreadSafepointState::destroy(JavaThread *thread) { | |
| 884 if (thread->safepoint_state()) { | |
| 885 delete(thread->safepoint_state()); | |
| 886 thread->set_safepoint_state(NULL); | |
| 887 } | |
| 888 } | |
| 889 | |
| 890 void ThreadSafepointState::examine_state_of_thread() { | |
| 891 assert(is_running(), "better be running or just have hit safepoint poll"); | |
| 892 | |
| 893 JavaThreadState state = _thread->thread_state(); | |
| 894 | |
|
1727
da877bdc9000
6975006: assert(check.is_deoptimized_frame()) failed: missed deopt
never
parents:
1552
diff
changeset
|
895 // Save the state at the start of safepoint processing. |
|
da877bdc9000
6975006: assert(check.is_deoptimized_frame()) failed: missed deopt
never
parents:
1552
diff
changeset
|
896 _orig_thread_state = state; |
|
da877bdc9000
6975006: assert(check.is_deoptimized_frame()) failed: missed deopt
never
parents:
1552
diff
changeset
|
897 |
| 0 | 898 // Check for a thread that is suspended. Note that thread resume tries |
| 899 // to grab the Threads_lock which we own here, so a thread cannot be | |
| 900 // resumed during safepoint synchronization. | |
| 901 | |
| 979 | 902 // We check to see if this thread is suspended without locking to |
| 903 // avoid deadlocking with a third thread that is waiting for this | |
| 904 // thread to be suspended. The third thread can notice the safepoint | |
| 905 // that we're trying to start at the beginning of its SR_lock->wait() | |
| 906 // call. If that happens, then the third thread will block on the | |
| 907 // safepoint while still holding the underlying SR_lock. We won't be | |
| 908 // able to get the SR_lock and we'll deadlock. | |
| 909 // | |
| 910 // We don't need to grab the SR_lock here for two reasons: | |
| 911 // 1) The suspend flags are both volatile and are set with an | |
| 912 // Atomic::cmpxchg() call so we should see the suspended | |
| 913 // state right away. | |
| 914 // 2) We're being called from the safepoint polling loop; if | |
| 915 // we don't see the suspended state on this iteration, then | |
| 916 // we'll come around again. | |
| 917 // | |
| 918 bool is_suspended = _thread->is_ext_suspended(); | |
| 0 | 919 if (is_suspended) { |
| 920 roll_forward(_at_safepoint); | |
| 921 return; | |
| 922 } | |
| 923 | |
| 924 // Some JavaThread states have an initial safepoint state of | |
| 925 // running, but are actually at a safepoint. We will happily | |
| 926 // agree and update the safepoint state here. | |
| 927 if (SafepointSynchronize::safepoint_safe(_thread, state)) { | |
|
5928
541c4a5e7b88
7150390: JFR test crashed on assert(_jni_lock_count == count) failed: must be equal
never
parents:
4873
diff
changeset
|
928 SafepointSynchronize::check_for_lazy_critical_native(_thread, state); |
|
4867
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
929 roll_forward(_at_safepoint); |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
3960
diff
changeset
|
930 return; |
| 0 | 931 } |
| 932 | |
| 933 if (state == _thread_in_vm) { | |
| 934 roll_forward(_call_back); | |
| 935 return; | |
| 936 } | |
| 937 | |
| 938 // All other thread states will continue to run until they | |
| 939 // transition and self-block in state _blocked | |
| 940 // Safepoint polling in compiled code causes the Java threads to do the same. | |
| 941 // Note: new threads may require a malloc so they must be allowed to finish | |
| 942 | |
| 943 assert(is_running(), "examine_state_of_thread on non-running thread"); | |
| 944 return; | |
| 945 } | |
| 946 | |
| 947 // Returns true is thread could not be rolled forward at present position. | |
| 948 void ThreadSafepointState::roll_forward(suspend_type type) { | |
| 949 _type = type; | |
| 950 | |
| 951 switch(_type) { | |
| 952 case _at_safepoint: | |
| 953 SafepointSynchronize::signal_thread_at_safepoint(); | |
|
5928
541c4a5e7b88
7150390: JFR test crashed on assert(_jni_lock_count == count) failed: must be equal
never
parents:
4873
diff
changeset
|
954 DEBUG_ONLY(_thread->set_visited_for_critical_count(true)); |
|
541c4a5e7b88
7150390: JFR test crashed on assert(_jni_lock_count == count) failed: must be equal
never
parents:
4873
diff
changeset
|
955 if (_thread->in_critical()) { |
|
541c4a5e7b88
7150390: JFR test crashed on assert(_jni_lock_count == count) failed: must be equal
never
parents:
4873
diff
changeset
|
956 // Notice that this thread is in a critical section |
|
541c4a5e7b88
7150390: JFR test crashed on assert(_jni_lock_count == count) failed: must be equal
never
parents:
4873
diff
changeset
|
957 SafepointSynchronize::increment_jni_active_count(); |
|
541c4a5e7b88
7150390: JFR test crashed on assert(_jni_lock_count == count) failed: must be equal
never
parents:
4873
diff
changeset
|
958 } |
| 0 | 959 break; |
| 960 | |
| 961 case _call_back: | |
| 962 set_has_called_back(false); | |
| 963 break; | |
| 964 | |
| 965 case _running: | |
| 966 default: | |
| 967 ShouldNotReachHere(); | |
| 968 } | |
| 969 } | |
| 970 | |
| 971 void ThreadSafepointState::restart() { | |
| 972 switch(type()) { | |
| 973 case _at_safepoint: | |
| 974 case _call_back: | |
| 975 break; | |
| 976 | |
| 977 case _running: | |
| 978 default: | |
| 979 tty->print_cr("restart thread "INTPTR_FORMAT" with state %d", | |
| 980 _thread, _type); | |
| 981 _thread->print(); | |
| 982 ShouldNotReachHere(); | |
| 983 } | |
| 984 _type = _running; | |
| 985 set_has_called_back(false); | |
| 986 } | |
| 987 | |
| 988 | |
| 989 void ThreadSafepointState::print_on(outputStream *st) const { | |
| 990 const char *s; | |
| 991 | |
| 992 switch(_type) { | |
| 993 case _running : s = "_running"; break; | |
| 994 case _at_safepoint : s = "_at_safepoint"; break; | |
| 995 case _call_back : s = "_call_back"; break; | |
| 996 default: | |
| 997 ShouldNotReachHere(); | |
| 998 } | |
| 999 | |
| 1000 st->print_cr("Thread: " INTPTR_FORMAT | |
| 1001 " [0x%2x] State: %s _has_called_back %d _at_poll_safepoint %d", | |
| 1002 _thread, _thread->osthread()->thread_id(), s, _has_called_back, | |
| 1003 _at_poll_safepoint); | |
| 1004 | |
| 1005 _thread->print_thread_state_on(st); | |
| 1006 } | |
| 1007 | |
| 1008 | |
| 1009 // --------------------------------------------------------------------------------------------------------------------- | |
| 1010 | |
| 1011 // Block the thread at the safepoint poll or poll return. | |
| 1012 void ThreadSafepointState::handle_polling_page_exception() { | |
| 1013 | |
| 1014 // Check state. block() will set thread state to thread_in_vm which will | |
| 1015 // cause the safepoint state _type to become _call_back. | |
| 1016 assert(type() == ThreadSafepointState::_running, | |
| 1017 "polling page exception on thread not running state"); | |
| 1018 | |
| 1019 // Step 1: Find the nmethod from the return address | |
| 1020 if (ShowSafepointMsgs && Verbose) { | |
| 1021 tty->print_cr("Polling page exception at " INTPTR_FORMAT, thread()->saved_exception_pc()); | |
| 1022 } | |
| 1023 address real_return_addr = thread()->saved_exception_pc(); | |
| 1024 | |
| 1025 CodeBlob *cb = CodeCache::find_blob(real_return_addr); | |
| 1026 assert(cb != NULL && cb->is_nmethod(), "return address should be in nmethod"); | |
| 1027 nmethod* nm = (nmethod*)cb; | |
| 1028 | |
| 1029 // Find frame of caller | |
| 1030 frame stub_fr = thread()->last_frame(); | |
| 1031 CodeBlob* stub_cb = stub_fr.cb(); | |
| 1032 assert(stub_cb->is_safepoint_stub(), "must be a safepoint stub"); | |
| 1033 RegisterMap map(thread(), true); | |
| 1034 frame caller_fr = stub_fr.sender(&map); | |
| 1035 | |
| 1036 // Should only be poll_return or poll | |
| 1037 assert( nm->is_at_poll_or_poll_return(real_return_addr), "should not be at call" ); | |
| 1038 | |
| 1039 // This is a poll immediately before a return. The exception handling code | |
| 1040 // has already had the effect of causing the return to occur, so the execution | |
| 1041 // will continue immediately after the call. In addition, the oopmap at the | |
| 1042 // return point does not mark the return value as an oop (if it is), so | |
| 1043 // it needs a handle here to be updated. | |
| 1044 if( nm->is_at_poll_return(real_return_addr) ) { | |
| 1045 // See if return type is an oop. | |
| 1046 bool return_oop = nm->method()->is_returning_oop(); | |
| 1047 Handle return_value; | |
| 1048 if (return_oop) { | |
| 1049 // The oop result has been saved on the stack together with all | |
| 1050 // the other registers. In order to preserve it over GCs we need | |
| 1051 // to keep it in a handle. | |
| 1052 oop result = caller_fr.saved_oop_result(&map); | |
| 1053 assert(result == NULL || result->is_oop(), "must be oop"); | |
| 1054 return_value = Handle(thread(), result); | |
| 1055 assert(Universe::heap()->is_in_or_null(result), "must be heap pointer"); | |
| 1056 } | |
| 1057 | |
| 1058 // Block the thread | |
| 1059 SafepointSynchronize::block(thread()); | |
| 1060 | |
| 1061 // restore oop result, if any | |
| 1062 if (return_oop) { | |
| 1063 caller_fr.set_saved_oop_result(&map, return_value()); | |
| 1064 } | |
| 1065 } | |
| 1066 | |
| 1067 // This is a safepoint poll. Verify the return address and block. | |
| 1068 else { | |
| 1069 set_at_poll_safepoint(true); | |
| 1070 | |
| 1071 // verify the blob built the "return address" correctly | |
| 1072 assert(real_return_addr == caller_fr.pc(), "must match"); | |
| 1073 | |
| 1074 // Block the thread | |
| 1075 SafepointSynchronize::block(thread()); | |
| 1076 set_at_poll_safepoint(false); | |
| 1077 | |
| 1078 // If we have a pending async exception deoptimize the frame | |
| 1079 // as otherwise we may never deliver it. | |
| 1080 if (thread()->has_async_condition()) { | |
| 1081 ThreadInVMfromJavaNoAsyncException __tiv(thread()); | |
|
1905
ce6848d0666d
6968367: can_post_on_exceptions is still using VM_DeoptimizeFrame in some places
never
parents:
1783
diff
changeset
|
1082 Deoptimization::deoptimize_frame(thread(), caller_fr.id()); |
| 0 | 1083 } |
| 1084 | |
| 1085 // If an exception has been installed we must check for a pending deoptimization | |
| 1086 // Deoptimize frame if exception has been thrown. | |
| 1087 | |
| 1088 if (thread()->has_pending_exception() ) { | |
| 1089 RegisterMap map(thread(), true); | |
| 1090 frame caller_fr = stub_fr.sender(&map); | |
| 1091 if (caller_fr.is_deoptimized_frame()) { | |
| 1092 // The exception patch will destroy registers that are still | |
| 1093 // live and will be needed during deoptimization. Defer the | |
| 1094 // Async exception should have defered the exception until the | |
| 1095 // next safepoint which will be detected when we get into | |
| 1096 // the interpreter so if we have an exception now things | |
| 1097 // are messed up. | |
| 1098 | |
| 1099 fatal("Exception installed and deoptimization is pending"); | |
| 1100 } | |
| 1101 } | |
| 1102 } | |
| 1103 } | |
| 1104 | |
| 1105 | |
| 1106 // | |
| 1107 // Statistics & Instrumentations | |
| 1108 // | |
| 1109 SafepointSynchronize::SafepointStats* SafepointSynchronize::_safepoint_stats = NULL; | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1110 jlong SafepointSynchronize::_safepoint_begin_time = 0; |
| 0 | 1111 int SafepointSynchronize::_cur_stat_index = 0; |
| 1112 julong SafepointSynchronize::_safepoint_reasons[VM_Operation::VMOp_Terminating]; | |
| 1113 julong SafepointSynchronize::_coalesced_vmop_count = 0; | |
| 1114 jlong SafepointSynchronize::_max_sync_time = 0; | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1115 jlong SafepointSynchronize::_max_vmop_time = 0; |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1116 float SafepointSynchronize::_ts_of_current_safepoint = 0.0f; |
| 0 | 1117 |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1118 static jlong cleanup_end_time = 0; |
| 0 | 1119 static bool need_to_track_page_armed_status = false; |
| 1120 static bool init_done = false; | |
| 1121 | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1122 // Helper method to print the header. |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1123 static void print_header() { |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1124 tty->print(" vmop " |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1125 "[threads: total initially_running wait_to_block] "); |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1126 tty->print("[time: spin block sync cleanup vmop] "); |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1127 |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1128 // no page armed status printed out if it is always armed. |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1129 if (need_to_track_page_armed_status) { |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1130 tty->print("page_armed "); |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1131 } |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1132 |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1133 tty->print_cr("page_trap_count"); |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1134 } |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1135 |
| 0 | 1136 void SafepointSynchronize::deferred_initialize_stat() { |
| 1137 if (init_done) return; | |
| 1138 | |
| 1139 if (PrintSafepointStatisticsCount <= 0) { | |
| 1140 fatal("Wrong PrintSafepointStatisticsCount"); | |
| 1141 } | |
| 1142 | |
| 1143 // If PrintSafepointStatisticsTimeout is specified, the statistics data will | |
| 1144 // be printed right away, in which case, _safepoint_stats will regress to | |
| 1145 // a single element array. Otherwise, it is a circular ring buffer with default | |
| 1146 // size of PrintSafepointStatisticsCount. | |
| 1147 int stats_array_size; | |
| 1148 if (PrintSafepointStatisticsTimeout > 0) { | |
| 1149 stats_array_size = 1; | |
| 1150 PrintSafepointStatistics = true; | |
| 1151 } else { | |
| 1152 stats_array_size = PrintSafepointStatisticsCount; | |
| 1153 } | |
| 1154 _safepoint_stats = (SafepointStats*)os::malloc(stats_array_size | |
| 6197 | 1155 * sizeof(SafepointStats), mtInternal); |
| 0 | 1156 guarantee(_safepoint_stats != NULL, |
| 1157 "not enough memory for safepoint instrumentation data"); | |
| 1158 | |
| 1159 if (UseCompilerSafepoints && DeferPollingPageLoopCount >= 0) { | |
| 1160 need_to_track_page_armed_status = true; | |
| 1161 } | |
| 1162 init_done = true; | |
| 1163 } | |
| 1164 | |
| 1165 void SafepointSynchronize::begin_statistics(int nof_threads, int nof_running) { | |
| 1003 | 1166 assert(init_done, "safepoint statistics array hasn't been initialized"); |
| 0 | 1167 SafepointStats *spstat = &_safepoint_stats[_cur_stat_index]; |
| 1168 | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1169 spstat->_time_stamp = _ts_of_current_safepoint; |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1170 |
| 0 | 1171 VM_Operation *op = VMThread::vm_operation(); |
| 1172 spstat->_vmop_type = (op != NULL ? op->type() : -1); | |
| 1173 if (op != NULL) { | |
| 1174 _safepoint_reasons[spstat->_vmop_type]++; | |
| 1175 } | |
| 1176 | |
| 1177 spstat->_nof_total_threads = nof_threads; | |
| 1178 spstat->_nof_initial_running_threads = nof_running; | |
| 1179 spstat->_nof_threads_hit_page_trap = 0; | |
| 1180 | |
| 1181 // Records the start time of spinning. The real time spent on spinning | |
| 1182 // will be adjusted when spin is done. Same trick is applied for time | |
| 1183 // spent on waiting for threads to block. | |
| 1184 if (nof_running != 0) { | |
| 1185 spstat->_time_to_spin = os::javaTimeNanos(); | |
| 1186 } else { | |
| 1187 spstat->_time_to_spin = 0; | |
| 1188 } | |
| 1189 } | |
| 1190 | |
| 1191 void SafepointSynchronize::update_statistics_on_spin_end() { | |
| 1192 SafepointStats *spstat = &_safepoint_stats[_cur_stat_index]; | |
| 1193 | |
| 1194 jlong cur_time = os::javaTimeNanos(); | |
| 1195 | |
| 1196 spstat->_nof_threads_wait_to_block = _waiting_to_block; | |
| 1197 if (spstat->_nof_initial_running_threads != 0) { | |
| 1198 spstat->_time_to_spin = cur_time - spstat->_time_to_spin; | |
| 1199 } | |
| 1200 | |
| 1201 if (need_to_track_page_armed_status) { | |
| 1202 spstat->_page_armed = (PageArmed == 1); | |
| 1203 } | |
| 1204 | |
| 1205 // Records the start time of waiting for to block. Updated when block is done. | |
| 1206 if (_waiting_to_block != 0) { | |
| 1207 spstat->_time_to_wait_to_block = cur_time; | |
| 1208 } else { | |
| 1209 spstat->_time_to_wait_to_block = 0; | |
| 1210 } | |
| 1211 } | |
| 1212 | |
| 1213 void SafepointSynchronize::update_statistics_on_sync_end(jlong end_time) { | |
| 1214 SafepointStats *spstat = &_safepoint_stats[_cur_stat_index]; | |
| 1215 | |
| 1216 if (spstat->_nof_threads_wait_to_block != 0) { | |
| 1217 spstat->_time_to_wait_to_block = end_time - | |
| 1218 spstat->_time_to_wait_to_block; | |
| 1219 } | |
| 1220 | |
| 1221 // Records the end time of sync which will be used to calculate the total | |
| 1222 // vm operation time. Again, the real time spending in syncing will be deducted | |
| 1223 // from the start of the sync time later when end_statistics is called. | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1224 spstat->_time_to_sync = end_time - _safepoint_begin_time; |
| 0 | 1225 if (spstat->_time_to_sync > _max_sync_time) { |
| 1226 _max_sync_time = spstat->_time_to_sync; | |
| 1227 } | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1228 |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1229 spstat->_time_to_do_cleanups = end_time; |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1230 } |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1231 |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1232 void SafepointSynchronize::update_statistics_on_cleanup_end(jlong end_time) { |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1233 SafepointStats *spstat = &_safepoint_stats[_cur_stat_index]; |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1234 |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1235 // Record how long spent in cleanup tasks. |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1236 spstat->_time_to_do_cleanups = end_time - spstat->_time_to_do_cleanups; |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1237 |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1238 cleanup_end_time = end_time; |
| 0 | 1239 } |
| 1240 | |
| 1241 void SafepointSynchronize::end_statistics(jlong vmop_end_time) { | |
| 1242 SafepointStats *spstat = &_safepoint_stats[_cur_stat_index]; | |
| 1243 | |
| 1244 // Update the vm operation time. | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1245 spstat->_time_to_exec_vmop = vmop_end_time - cleanup_end_time; |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1246 if (spstat->_time_to_exec_vmop > _max_vmop_time) { |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1247 _max_vmop_time = spstat->_time_to_exec_vmop; |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1248 } |
| 0 | 1249 // Only the sync time longer than the specified |
| 1250 // PrintSafepointStatisticsTimeout will be printed out right away. | |
| 1251 // By default, it is -1 meaning all samples will be put into the list. | |
| 1252 if ( PrintSafepointStatisticsTimeout > 0) { | |
| 1253 if (spstat->_time_to_sync > PrintSafepointStatisticsTimeout * MICROUNITS) { | |
| 1254 print_statistics(); | |
| 1255 } | |
| 1256 } else { | |
| 1257 // The safepoint statistics will be printed out when the _safepoin_stats | |
| 1258 // array fills up. | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1259 if (_cur_stat_index == PrintSafepointStatisticsCount - 1) { |
| 0 | 1260 print_statistics(); |
| 1261 _cur_stat_index = 0; | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1262 } else { |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1263 _cur_stat_index++; |
| 0 | 1264 } |
| 1265 } | |
| 1266 } | |
| 1267 | |
| 1268 void SafepointSynchronize::print_statistics() { | |
| 1269 SafepointStats* sstats = _safepoint_stats; | |
| 1270 | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1271 for (int index = 0; index <= _cur_stat_index; index++) { |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1272 if (index % 30 == 0) { |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1273 print_header(); |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1274 } |
| 0 | 1275 sstats = &_safepoint_stats[index]; |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1276 tty->print("%.3f: ", sstats->_time_stamp); |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1277 tty->print("%-26s [" |
| 0 | 1278 INT32_FORMAT_W(8)INT32_FORMAT_W(11)INT32_FORMAT_W(15) |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1279 " ] ", |
| 0 | 1280 sstats->_vmop_type == -1 ? "no vm operation" : |
| 1281 VM_Operation::name(sstats->_vmop_type), | |
| 1282 sstats->_nof_total_threads, | |
| 1283 sstats->_nof_initial_running_threads, | |
| 1284 sstats->_nof_threads_wait_to_block); | |
| 1285 // "/ MICROUNITS " is to convert the unit from nanos to millis. | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1286 tty->print(" [" |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1287 INT64_FORMAT_W(6)INT64_FORMAT_W(6) |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1288 INT64_FORMAT_W(6)INT64_FORMAT_W(6) |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1289 INT64_FORMAT_W(6)" ] ", |
| 0 | 1290 sstats->_time_to_spin / MICROUNITS, |
| 1291 sstats->_time_to_wait_to_block / MICROUNITS, | |
| 1292 sstats->_time_to_sync / MICROUNITS, | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1293 sstats->_time_to_do_cleanups / MICROUNITS, |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1294 sstats->_time_to_exec_vmop / MICROUNITS); |
| 0 | 1295 |
| 1296 if (need_to_track_page_armed_status) { | |
| 1297 tty->print(INT32_FORMAT" ", sstats->_page_armed); | |
| 1298 } | |
| 1299 tty->print_cr(INT32_FORMAT" ", sstats->_nof_threads_hit_page_trap); | |
| 1300 } | |
| 1301 } | |
| 1302 | |
| 1303 // This method will be called when VM exits. It will first call | |
| 1304 // print_statistics to print out the rest of the sampling. Then | |
| 1305 // it tries to summarize the sampling. | |
| 1306 void SafepointSynchronize::print_stat_on_exit() { | |
| 1307 if (_safepoint_stats == NULL) return; | |
| 1308 | |
| 1309 SafepointStats *spstat = &_safepoint_stats[_cur_stat_index]; | |
| 1310 | |
| 1311 // During VM exit, end_statistics may not get called and in that | |
| 1312 // case, if the sync time is less than PrintSafepointStatisticsTimeout, | |
| 1313 // don't print it out. | |
| 1314 // Approximate the vm op time. | |
| 1315 _safepoint_stats[_cur_stat_index]._time_to_exec_vmop = | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1316 os::javaTimeNanos() - cleanup_end_time; |
| 0 | 1317 |
| 1318 if ( PrintSafepointStatisticsTimeout < 0 || | |
| 1319 spstat->_time_to_sync > PrintSafepointStatisticsTimeout * MICROUNITS) { | |
| 1320 print_statistics(); | |
| 1321 } | |
| 1322 tty->print_cr(""); | |
| 1323 | |
| 1324 // Print out polling page sampling status. | |
| 1325 if (!need_to_track_page_armed_status) { | |
| 1326 if (UseCompilerSafepoints) { | |
| 1327 tty->print_cr("Polling page always armed"); | |
| 1328 } | |
| 1329 } else { | |
| 1330 tty->print_cr("Defer polling page loop count = %d\n", | |
| 1331 DeferPollingPageLoopCount); | |
| 1332 } | |
| 1333 | |
| 1334 for (int index = 0; index < VM_Operation::VMOp_Terminating; index++) { | |
| 1335 if (_safepoint_reasons[index] != 0) { | |
| 1336 tty->print_cr("%-26s"UINT64_FORMAT_W(10), VM_Operation::name(index), | |
| 1337 _safepoint_reasons[index]); | |
| 1338 } | |
| 1339 } | |
| 1340 | |
| 1341 tty->print_cr(UINT64_FORMAT_W(5)" VM operations coalesced during safepoint", | |
| 1342 _coalesced_vmop_count); | |
| 1343 tty->print_cr("Maximum sync time "INT64_FORMAT_W(5)" ms", | |
| 1344 _max_sync_time / MICROUNITS); | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1345 tty->print_cr("Maximum vm operation time (except for Exit VM operation) " |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1346 INT64_FORMAT_W(5)" ms", |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1347 _max_vmop_time / MICROUNITS); |
| 0 | 1348 } |
| 1349 | |
| 1350 // ------------------------------------------------------------------------------------------------ | |
| 1351 // Non-product code | |
| 1352 | |
| 1353 #ifndef PRODUCT | |
| 1354 | |
| 1355 void SafepointSynchronize::print_state() { | |
| 1356 if (_state == _not_synchronized) { | |
| 1357 tty->print_cr("not synchronized"); | |
| 1358 } else if (_state == _synchronizing || _state == _synchronized) { | |
| 1359 tty->print_cr("State: %s", (_state == _synchronizing) ? "synchronizing" : | |
| 1360 "synchronized"); | |
| 1361 | |
| 1362 for(JavaThread *cur = Threads::first(); cur; cur = cur->next()) { | |
| 1363 cur->safepoint_state()->print(); | |
| 1364 } | |
| 1365 } | |
| 1366 } | |
| 1367 | |
| 1368 void SafepointSynchronize::safepoint_msg(const char* format, ...) { | |
| 1369 if (ShowSafepointMsgs) { | |
| 1370 va_list ap; | |
| 1371 va_start(ap, format); | |
| 1372 tty->vprint_cr(format, ap); | |
| 1373 va_end(ap); | |
| 1374 } | |
| 1375 } | |
| 1376 | |
| 1377 #endif // !PRODUCT |