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