Mercurial > hg > graal-compiler
annotate src/share/vm/runtime/safepoint.cpp @ 3917:eca1193ca245
4965777: GC changes to support use of discovered field for pending references
Summary: If and when the reference handler thread is able to use the discovered field to link reference objects in its pending list, so will GC. In that case, GC will scan through this field once a reference object has been placed on the pending list, but not scan that field before that stage, as the field is used by the concurrent GC thread to link discovered objects. When ReferenceHandleR thread does not use the discovered field for the purpose of linking the elements in the pending list, as would be the case in older JDKs, the JVM will fall back to the old behaviour of using the next field for that purpose.
Reviewed-by: jcoomes, mchung, stefank
| author | ysr |
|---|---|
| date | Wed, 07 Sep 2011 13:55:42 -0700 |
| parents | 2a241e764894 |
| children | f08d439fab8c |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
2426
1d1603768966
7010070: Update all 2010 Oracle-changed OpenJDK files to have the proper copyright dates - second pass
trims
parents:
2192
diff
changeset
|
2 * Copyright (c) 1997, 2011, 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" |
| 26 #include "classfile/systemDictionary.hpp" | |
| 27 #include "code/codeCache.hpp" | |
| 28 #include "code/icBuffer.hpp" | |
| 29 #include "code/nmethod.hpp" | |
| 30 #include "code/pcDesc.hpp" | |
| 31 #include "code/scopeDesc.hpp" | |
| 32 #include "gc_interface/collectedHeap.hpp" | |
| 33 #include "interpreter/interpreter.hpp" | |
| 34 #include "memory/resourceArea.hpp" | |
| 35 #include "memory/universe.inline.hpp" | |
| 36 #include "oops/oop.inline.hpp" | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
37 #include "oops/symbol.hpp" |
| 1972 | 38 #include "runtime/compilationPolicy.hpp" |
| 39 #include "runtime/deoptimization.hpp" | |
| 40 #include "runtime/frame.inline.hpp" | |
| 41 #include "runtime/interfaceSupport.hpp" | |
| 42 #include "runtime/mutexLocker.hpp" | |
| 43 #include "runtime/osThread.hpp" | |
| 44 #include "runtime/safepoint.hpp" | |
| 45 #include "runtime/signature.hpp" | |
| 46 #include "runtime/stubCodeGenerator.hpp" | |
| 47 #include "runtime/stubRoutines.hpp" | |
| 48 #include "runtime/sweeper.hpp" | |
| 49 #include "runtime/synchronizer.hpp" | |
| 50 #include "services/runtimeService.hpp" | |
| 51 #include "utilities/events.hpp" | |
| 52 #ifdef TARGET_ARCH_x86 | |
| 53 # include "nativeInst_x86.hpp" | |
| 54 # include "vmreg_x86.inline.hpp" | |
| 55 #endif | |
| 56 #ifdef TARGET_ARCH_sparc | |
| 57 # include "nativeInst_sparc.hpp" | |
| 58 # include "vmreg_sparc.inline.hpp" | |
| 59 #endif | |
| 60 #ifdef TARGET_ARCH_zero | |
| 61 # include "nativeInst_zero.hpp" | |
| 62 # include "vmreg_zero.inline.hpp" | |
| 63 #endif | |
|
2192
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
64 #ifdef TARGET_ARCH_arm |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
65 # include "nativeInst_arm.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
66 # include "vmreg_arm.inline.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
67 #endif |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
68 #ifdef TARGET_ARCH_ppc |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
69 # include "nativeInst_ppc.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
70 # include "vmreg_ppc.inline.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
71 #endif |
| 1972 | 72 #ifdef TARGET_OS_FAMILY_linux |
| 73 # include "thread_linux.inline.hpp" | |
| 74 #endif | |
| 75 #ifdef TARGET_OS_FAMILY_solaris | |
| 76 # include "thread_solaris.inline.hpp" | |
| 77 #endif | |
| 78 #ifdef TARGET_OS_FAMILY_windows | |
| 79 # include "thread_windows.inline.hpp" | |
| 80 #endif | |
| 81 #ifndef SERIALGC | |
| 82 #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepThread.hpp" | |
| 83 #include "gc_implementation/shared/concurrentGCThread.hpp" | |
| 84 #endif | |
| 85 #ifdef COMPILER1 | |
| 86 #include "c1/c1_globals.hpp" | |
| 87 #endif | |
| 0 | 88 |
| 89 // -------------------------------------------------------------------------------------------------- | |
| 90 // Implementation of Safepoint begin/end | |
| 91 | |
| 92 SafepointSynchronize::SynchronizeState volatile SafepointSynchronize::_state = SafepointSynchronize::_not_synchronized; | |
| 93 volatile int SafepointSynchronize::_waiting_to_block = 0; | |
| 94 volatile int SafepointSynchronize::_safepoint_counter = 0; | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
95 long SafepointSynchronize::_end_of_last_safepoint = 0; |
| 0 | 96 static volatile int PageArmed = 0 ; // safepoint polling page is RO|RW vs PROT_NONE |
| 97 static volatile int TryingToBlock = 0 ; // proximate value -- for advisory use only | |
| 98 static bool timeout_error_printed = false; | |
| 99 | |
| 100 // Roll all threads forward to a safepoint and suspend them all | |
| 101 void SafepointSynchronize::begin() { | |
| 102 | |
| 103 Thread* myThread = Thread::current(); | |
| 104 assert(myThread->is_VM_thread(), "Only VM thread may execute a safepoint"); | |
| 105 | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
106 if (PrintSafepointStatistics || PrintSafepointStatisticsTimeout > 0) { |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
107 _safepoint_begin_time = os::javaTimeNanos(); |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
108 _ts_of_current_safepoint = tty->time_stamp().seconds(); |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
109 } |
| 0 | 110 |
| 111 #ifndef SERIALGC | |
| 112 if (UseConcMarkSweepGC) { | |
| 113 // In the future we should investigate whether CMS can use the | |
| 114 // more-general mechanism below. DLD (01/05). | |
| 115 ConcurrentMarkSweepThread::synchronize(false); | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
628
diff
changeset
|
116 } else if (UseG1GC) { |
| 0 | 117 ConcurrentGCThread::safepoint_synchronize(); |
| 118 } | |
| 119 #endif // SERIALGC | |
| 120 | |
| 121 // By getting the Threads_lock, we assure that no threads are about to start or | |
| 122 // exit. It is released again in SafepointSynchronize::end(). | |
| 123 Threads_lock->lock(); | |
| 124 | |
| 125 assert( _state == _not_synchronized, "trying to safepoint synchronize with wrong state"); | |
| 126 | |
| 127 int nof_threads = Threads::number_of_threads(); | |
| 128 | |
| 129 if (TraceSafepoint) { | |
| 130 tty->print_cr("Safepoint synchronization initiated. (%d)", nof_threads); | |
| 131 } | |
| 132 | |
| 133 RuntimeService::record_safepoint_begin(); | |
| 134 | |
| 135 { | |
| 136 MutexLocker mu(Safepoint_lock); | |
| 137 | |
| 138 // Set number of threads to wait for, before we initiate the callbacks | |
| 139 _waiting_to_block = nof_threads; | |
| 140 TryingToBlock = 0 ; | |
| 141 int still_running = nof_threads; | |
| 142 | |
| 143 // Save the starting time, so that it can be compared to see if this has taken | |
| 144 // too long to complete. | |
| 145 jlong safepoint_limit_time; | |
| 146 timeout_error_printed = false; | |
| 147 | |
| 1003 | 148 // PrintSafepointStatisticsTimeout can be specified separately. When |
| 149 // specified, PrintSafepointStatistics will be set to true in | |
| 150 // deferred_initialize_stat method. The initialization has to be done | |
| 151 // early enough to avoid any races. See bug 6880029 for details. | |
| 152 if (PrintSafepointStatistics || PrintSafepointStatisticsTimeout > 0) { | |
| 153 deferred_initialize_stat(); | |
| 154 } | |
| 155 | |
| 0 | 156 // Begin the process of bringing the system to a safepoint. |
| 157 // Java threads can be in several different states and are | |
| 158 // stopped by different mechanisms: | |
| 159 // | |
| 160 // 1. Running interpreted | |
| 161 // The interpeter dispatch table is changed to force it to | |
| 162 // check for a safepoint condition between bytecodes. | |
| 163 // 2. Running in native code | |
| 164 // When returning from the native code, a Java thread must check | |
| 165 // the safepoint _state to see if we must block. If the | |
| 166 // VM thread sees a Java thread in native, it does | |
| 167 // not wait for this thread to block. The order of the memory | |
| 168 // writes and reads of both the safepoint state and the Java | |
| 169 // threads state is critical. In order to guarantee that the | |
| 170 // memory writes are serialized with respect to each other, | |
| 171 // the VM thread issues a memory barrier instruction | |
| 172 // (on MP systems). In order to avoid the overhead of issuing | |
| 173 // a memory barrier for each Java thread making native calls, each Java | |
| 174 // thread performs a write to a single memory page after changing | |
| 175 // the thread state. The VM thread performs a sequence of | |
| 176 // mprotect OS calls which forces all previous writes from all | |
| 177 // Java threads to be serialized. This is done in the | |
| 178 // os::serialize_thread_states() call. This has proven to be | |
| 179 // much more efficient than executing a membar instruction | |
| 180 // on every call to native code. | |
| 181 // 3. Running compiled Code | |
| 182 // Compiled code reads a global (Safepoint Polling) page that | |
| 183 // is set to fault if we are trying to get to a safepoint. | |
| 184 // 4. Blocked | |
| 185 // A thread which is blocked will not be allowed to return from the | |
| 186 // block condition until the safepoint operation is complete. | |
| 187 // 5. In VM or Transitioning between states | |
| 188 // If a Java thread is currently running in the VM or transitioning | |
| 189 // between states, the safepointing code will wait for the thread to | |
| 190 // block itself when it attempts transitions to a new state. | |
| 191 // | |
| 192 _state = _synchronizing; | |
| 193 OrderAccess::fence(); | |
| 194 | |
| 195 // Flush all thread states to memory | |
| 196 if (!UseMembar) { | |
| 197 os::serialize_thread_states(); | |
| 198 } | |
| 199 | |
| 200 // Make interpreter safepoint aware | |
| 201 Interpreter::notice_safepoints(); | |
| 202 | |
| 203 if (UseCompilerSafepoints && DeferPollingPageLoopCount < 0) { | |
| 204 // Make polling safepoint aware | |
| 205 guarantee (PageArmed == 0, "invariant") ; | |
| 206 PageArmed = 1 ; | |
| 207 os::make_polling_page_unreadable(); | |
| 208 } | |
| 209 | |
| 210 // Consider using active_processor_count() ... but that call is expensive. | |
| 211 int ncpus = os::processor_count() ; | |
| 212 | |
| 213 #ifdef ASSERT | |
| 214 for (JavaThread *cur = Threads::first(); cur != NULL; cur = cur->next()) { | |
| 215 assert(cur->safepoint_state()->is_running(), "Illegal initial state"); | |
| 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 | |
| 375 if (TraceSafepoint) { | |
| 376 VM_Operation *op = VMThread::vm_operation(); | |
| 377 tty->print_cr("Entering safepoint region: %s", (op != NULL) ? op->name() : "no vm operation"); | |
| 378 } | |
| 379 | |
| 380 RuntimeService::record_safepoint_synchronized(); | |
| 381 if (PrintSafepointStatistics) { | |
| 382 update_statistics_on_sync_end(os::javaTimeNanos()); | |
| 383 } | |
| 384 | |
| 385 // Call stuff that needs to be run when a safepoint is just about to be completed | |
| 386 do_cleanup_tasks(); | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
387 |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
388 if (PrintSafepointStatistics) { |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
389 // 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
|
390 update_statistics_on_cleanup_end(os::javaTimeNanos()); |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
391 } |
| 0 | 392 } |
| 393 } | |
| 394 | |
| 395 // Wake up all threads, so they are ready to resume execution after the safepoint | |
| 396 // operation has been carried out | |
| 397 void SafepointSynchronize::end() { | |
| 398 | |
| 399 assert(Threads_lock->owned_by_self(), "must hold Threads_lock"); | |
| 400 assert((_safepoint_counter & 0x1) == 1, "must be odd"); | |
| 401 _safepoint_counter ++; | |
| 402 // memory fence isn't required here since an odd _safepoint_counter | |
| 403 // value can do no harm and a fence is issued below anyway. | |
| 404 | |
| 405 DEBUG_ONLY(Thread* myThread = Thread::current();) | |
| 406 assert(myThread->is_VM_thread(), "Only VM thread can execute a safepoint"); | |
| 407 | |
| 408 if (PrintSafepointStatistics) { | |
| 409 end_statistics(os::javaTimeNanos()); | |
| 410 } | |
| 411 | |
| 412 #ifdef ASSERT | |
| 413 // A pending_exception cannot be installed during a safepoint. The threads | |
| 414 // may install an async exception after they come back from a safepoint into | |
| 415 // pending_exception after they unblock. But that should happen later. | |
| 416 for(JavaThread *cur = Threads::first(); cur; cur = cur->next()) { | |
| 417 assert (!(cur->has_pending_exception() && | |
| 418 cur->safepoint_state()->is_at_poll_safepoint()), | |
| 419 "safepoint installed a pending exception"); | |
| 420 } | |
| 421 #endif // ASSERT | |
| 422 | |
| 423 if (PageArmed) { | |
| 424 // Make polling safepoint aware | |
| 425 os::make_polling_page_readable(); | |
| 426 PageArmed = 0 ; | |
| 427 } | |
| 428 | |
| 429 // Remove safepoint check from interpreter | |
| 430 Interpreter::ignore_safepoints(); | |
| 431 | |
| 432 { | |
| 433 MutexLocker mu(Safepoint_lock); | |
| 434 | |
| 435 assert(_state == _synchronized, "must be synchronized before ending safepoint synchronization"); | |
| 436 | |
| 437 // Set to not synchronized, so the threads will not go into the signal_thread_blocked method | |
| 438 // when they get restarted. | |
| 439 _state = _not_synchronized; | |
| 440 OrderAccess::fence(); | |
| 441 | |
| 442 if (TraceSafepoint) { | |
| 443 tty->print_cr("Leaving safepoint region"); | |
| 444 } | |
| 445 | |
| 446 // Start suspended threads | |
| 447 for(JavaThread *current = Threads::first(); current; current = current->next()) { | |
| 605 | 448 // A problem occurring on Solaris is when attempting to restart threads |
| 0 | 449 // the first #cpus - 1 go well, but then the VMThread is preempted when we get |
| 450 // to the next one (since it has been running the longest). We then have | |
| 451 // to wait for a cpu to become available before we can continue restarting | |
| 452 // threads. | |
| 453 // FIXME: This causes the performance of the VM to degrade when active and with | |
| 454 // large numbers of threads. Apparently this is due to the synchronous nature | |
| 455 // of suspending threads. | |
| 456 // | |
| 457 // TODO-FIXME: the comments above are vestigial and no longer apply. | |
| 458 // Furthermore, using solaris' schedctl in this particular context confers no benefit | |
| 459 if (VMThreadHintNoPreempt) { | |
| 460 os::hint_no_preempt(); | |
| 461 } | |
| 462 ThreadSafepointState* cur_state = current->safepoint_state(); | |
| 463 assert(cur_state->type() != ThreadSafepointState::_running, "Thread not suspended at safepoint"); | |
| 464 cur_state->restart(); | |
| 465 assert(cur_state->is_running(), "safepoint state has not been reset"); | |
| 466 } | |
| 467 | |
| 468 RuntimeService::record_safepoint_end(); | |
| 469 | |
| 470 // Release threads lock, so threads can be created/destroyed again. It will also starts all threads | |
| 471 // blocked in signal_thread_blocked | |
| 472 Threads_lock->unlock(); | |
| 473 | |
| 474 } | |
| 475 #ifndef SERIALGC | |
| 476 // If there are any concurrent GC threads resume them. | |
| 477 if (UseConcMarkSweepGC) { | |
| 478 ConcurrentMarkSweepThread::desynchronize(false); | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
628
diff
changeset
|
479 } else if (UseG1GC) { |
| 0 | 480 ConcurrentGCThread::safepoint_desynchronize(); |
| 481 } | |
| 482 #endif // SERIALGC | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
483 // 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
|
484 // since last safepoint. |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
485 _end_of_last_safepoint = os::javaTimeMillis(); |
| 0 | 486 } |
| 487 | |
| 488 bool SafepointSynchronize::is_cleanup_needed() { | |
| 489 // Need a safepoint if some inline cache buffers is non-empty | |
| 490 if (!InlineCacheBuffer::is_empty()) return true; | |
| 491 return false; | |
| 492 } | |
| 493 | |
| 494 | |
| 495 | |
| 496 // Various cleaning tasks that should be done periodically at safepoints | |
| 497 void SafepointSynchronize::do_cleanup_tasks() { | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
498 { |
|
1321
0f6600cee529
6934758: Expose the break down of clean up task time during safepoint.
xlu
parents:
1291
diff
changeset
|
499 TraceTime t1("deflating idle monitors", TraceSafepointCleanupTime); |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
500 ObjectSynchronizer::deflate_idle_monitors(); |
| 0 | 501 } |
| 502 | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
503 { |
|
1321
0f6600cee529
6934758: Expose the break down of clean up task time during safepoint.
xlu
parents:
1291
diff
changeset
|
504 TraceTime t2("updating inline caches", TraceSafepointCleanupTime); |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
505 InlineCacheBuffer::update_inline_caches(); |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
506 } |
| 1783 | 507 { |
| 508 TraceTime t3("compilation policy safepoint handler", TraceSafepointCleanupTime); | |
| 509 CompilationPolicy::policy()->do_safepoint_work(); | |
| 0 | 510 } |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
511 |
|
1321
0f6600cee529
6934758: Expose the break down of clean up task time during safepoint.
xlu
parents:
1291
diff
changeset
|
512 TraceTime t4("sweeping nmethods", TraceSafepointCleanupTime); |
|
1538
bfe29ec02863
6950075: nmethod sweeper should operate concurrently
never
parents:
1490
diff
changeset
|
513 NMethodSweeper::scan_stacks(); |
|
3767
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
2426
diff
changeset
|
514 |
|
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
2426
diff
changeset
|
515 // rotate log files? |
|
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
2426
diff
changeset
|
516 if (UseGCLogFileRotation) { |
|
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
2426
diff
changeset
|
517 gclog_or_tty->rotate_log(); |
|
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
2426
diff
changeset
|
518 } |
| 0 | 519 } |
| 520 | |
| 521 | |
| 522 bool SafepointSynchronize::safepoint_safe(JavaThread *thread, JavaThreadState state) { | |
| 523 switch(state) { | |
| 524 case _thread_in_native: | |
| 525 // native threads are safe if they have no java stack or have walkable stack | |
| 526 return !thread->has_last_Java_frame() || thread->frame_anchor()->walkable(); | |
| 527 | |
| 528 // blocked threads should have already have walkable stack | |
| 529 case _thread_blocked: | |
| 530 assert(!thread->has_last_Java_frame() || thread->frame_anchor()->walkable(), "blocked and not walkable"); | |
| 531 return true; | |
| 532 | |
| 533 default: | |
| 534 return false; | |
| 535 } | |
| 536 } | |
| 537 | |
| 538 | |
| 539 // ------------------------------------------------------------------------------------------------------- | |
| 540 // Implementation of Safepoint callback point | |
| 541 | |
| 542 void SafepointSynchronize::block(JavaThread *thread) { | |
| 543 assert(thread != NULL, "thread must be set"); | |
| 544 assert(thread->is_Java_thread(), "not a Java thread"); | |
| 545 | |
| 546 // Threads shouldn't block if they are in the middle of printing, but... | |
| 547 ttyLocker::break_tty_lock_for_safepoint(os::current_thread_id()); | |
| 548 | |
| 549 // Only bail from the block() call if the thread is gone from the | |
| 550 // thread list; starting to exit should still block. | |
| 551 if (thread->is_terminated()) { | |
| 552 // block current thread if we come here from native code when VM is gone | |
| 553 thread->block_if_vm_exited(); | |
| 554 | |
| 555 // otherwise do nothing | |
| 556 return; | |
| 557 } | |
| 558 | |
| 559 JavaThreadState state = thread->thread_state(); | |
| 560 thread->frame_anchor()->make_walkable(thread); | |
| 561 | |
| 562 // Check that we have a valid thread_state at this point | |
| 563 switch(state) { | |
| 564 case _thread_in_vm_trans: | |
| 565 case _thread_in_Java: // From compiled code | |
| 566 | |
| 567 // We are highly likely to block on the Safepoint_lock. In order to avoid blocking in this case, | |
| 568 // we pretend we are still in the VM. | |
| 569 thread->set_thread_state(_thread_in_vm); | |
| 570 | |
| 571 if (is_synchronizing()) { | |
| 572 Atomic::inc (&TryingToBlock) ; | |
| 573 } | |
| 574 | |
| 575 // We will always be holding the Safepoint_lock when we are examine the state | |
| 576 // of a thread. Hence, the instructions between the Safepoint_lock->lock() and | |
| 577 // Safepoint_lock->unlock() are happening atomic with regards to the safepoint code | |
| 578 Safepoint_lock->lock_without_safepoint_check(); | |
| 579 if (is_synchronizing()) { | |
| 580 // Decrement the number of threads to wait for and signal vm thread | |
| 581 assert(_waiting_to_block > 0, "sanity check"); | |
| 582 _waiting_to_block--; | |
| 583 thread->safepoint_state()->set_has_called_back(true); | |
| 584 | |
| 585 // Consider (_waiting_to_block < 2) to pipeline the wakeup of the VM thread | |
| 586 if (_waiting_to_block == 0) { | |
| 587 Safepoint_lock->notify_all(); | |
| 588 } | |
| 589 } | |
| 590 | |
| 591 // We transition the thread to state _thread_blocked here, but | |
| 592 // we can't do our usual check for external suspension and then | |
| 593 // self-suspend after the lock_without_safepoint_check() call | |
| 594 // below because we are often called during transitions while | |
| 595 // we hold different locks. That would leave us suspended while | |
| 596 // holding a resource which results in deadlocks. | |
| 597 thread->set_thread_state(_thread_blocked); | |
| 598 Safepoint_lock->unlock(); | |
| 599 | |
| 600 // We now try to acquire the threads lock. Since this lock is hold by the VM thread during | |
| 601 // the entire safepoint, the threads will all line up here during the safepoint. | |
| 602 Threads_lock->lock_without_safepoint_check(); | |
| 603 // restore original state. This is important if the thread comes from compiled code, so it | |
| 604 // will continue to execute with the _thread_in_Java state. | |
| 605 thread->set_thread_state(state); | |
| 606 Threads_lock->unlock(); | |
| 607 break; | |
| 608 | |
| 609 case _thread_in_native_trans: | |
| 610 case _thread_blocked_trans: | |
| 611 case _thread_new_trans: | |
| 612 if (thread->safepoint_state()->type() == ThreadSafepointState::_call_back) { | |
| 613 thread->print_thread_state(); | |
| 614 fatal("Deadlock in safepoint code. " | |
| 615 "Should have called back to the VM before blocking."); | |
| 616 } | |
| 617 | |
| 618 // We transition the thread to state _thread_blocked here, but | |
| 619 // we can't do our usual check for external suspension and then | |
| 620 // self-suspend after the lock_without_safepoint_check() call | |
| 621 // below because we are often called during transitions while | |
| 622 // we hold different locks. That would leave us suspended while | |
| 623 // holding a resource which results in deadlocks. | |
| 624 thread->set_thread_state(_thread_blocked); | |
| 625 | |
| 626 // It is not safe to suspend a thread if we discover it is in _thread_in_native_trans. Hence, | |
| 627 // the safepoint code might still be waiting for it to block. We need to change the state here, | |
| 628 // so it can see that it is at a safepoint. | |
| 629 | |
| 630 // Block until the safepoint operation is completed. | |
| 631 Threads_lock->lock_without_safepoint_check(); | |
| 632 | |
| 633 // Restore state | |
| 634 thread->set_thread_state(state); | |
| 635 | |
| 636 Threads_lock->unlock(); | |
| 637 break; | |
| 638 | |
| 639 default: | |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1321
diff
changeset
|
640 fatal(err_msg("Illegal threadstate encountered: %d", state)); |
| 0 | 641 } |
| 642 | |
| 643 // Check for pending. async. exceptions or suspends - except if the | |
| 644 // thread was blocked inside the VM. has_special_runtime_exit_condition() | |
| 645 // is called last since it grabs a lock and we only want to do that when | |
| 646 // we must. | |
| 647 // | |
| 648 // Note: we never deliver an async exception at a polling point as the | |
| 649 // compiler may not have an exception handler for it. The polling | |
| 650 // code will notice the async and deoptimize and the exception will | |
| 651 // be delivered. (Polling at a return point is ok though). Sure is | |
| 652 // a lot of bother for a deprecated feature... | |
| 653 // | |
| 654 // We don't deliver an async exception if the thread state is | |
| 655 // _thread_in_native_trans so JNI functions won't be called with | |
| 656 // a surprising pending exception. If the thread state is going back to java, | |
| 657 // async exception is checked in check_special_condition_for_native_trans(). | |
| 658 | |
| 659 if (state != _thread_blocked_trans && | |
| 660 state != _thread_in_vm_trans && | |
| 661 thread->has_special_runtime_exit_condition()) { | |
| 662 thread->handle_special_runtime_exit_condition( | |
| 663 !thread->is_at_poll_safepoint() && (state != _thread_in_native_trans)); | |
| 664 } | |
| 665 } | |
| 666 | |
| 667 // ------------------------------------------------------------------------------------------------------ | |
| 668 // Exception handlers | |
| 669 | |
| 670 #ifndef PRODUCT | |
| 671 #ifdef _LP64 | |
| 672 #define PTR_PAD "" | |
| 673 #else | |
| 674 #define PTR_PAD " " | |
| 675 #endif | |
| 676 | |
| 677 static void print_ptrs(intptr_t oldptr, intptr_t newptr, bool wasoop) { | |
| 678 bool is_oop = newptr ? ((oop)newptr)->is_oop() : false; | |
| 679 tty->print_cr(PTR_FORMAT PTR_PAD " %s %c " PTR_FORMAT PTR_PAD " %s %s", | |
| 680 oldptr, wasoop?"oop":" ", oldptr == newptr ? ' ' : '!', | |
| 681 newptr, is_oop?"oop":" ", (wasoop && !is_oop) ? "STALE" : ((wasoop==false&&is_oop==false&&oldptr !=newptr)?"STOMP":" ")); | |
| 682 } | |
| 683 | |
| 684 static void print_longs(jlong oldptr, jlong newptr, bool wasoop) { | |
| 685 bool is_oop = newptr ? ((oop)(intptr_t)newptr)->is_oop() : false; | |
| 686 tty->print_cr(PTR64_FORMAT " %s %c " PTR64_FORMAT " %s %s", | |
| 687 oldptr, wasoop?"oop":" ", oldptr == newptr ? ' ' : '!', | |
| 688 newptr, is_oop?"oop":" ", (wasoop && !is_oop) ? "STALE" : ((wasoop==false&&is_oop==false&&oldptr !=newptr)?"STOMP":" ")); | |
| 689 } | |
| 690 | |
| 691 #ifdef SPARC | |
| 692 static void print_me(intptr_t *new_sp, intptr_t *old_sp, bool *was_oops) { | |
| 693 #ifdef _LP64 | |
| 694 tty->print_cr("--------+------address-----+------before-----------+-------after----------+"); | |
| 695 const int incr = 1; // Increment to skip a long, in units of intptr_t | |
| 696 #else | |
| 697 tty->print_cr("--------+--address-+------before-----------+-------after----------+"); | |
| 698 const int incr = 2; // Increment to skip a long, in units of intptr_t | |
| 699 #endif | |
| 700 tty->print_cr("---SP---|"); | |
| 701 for( int i=0; i<16; i++ ) { | |
| 702 tty->print("blob %c%d |"PTR_FORMAT" ","LO"[i>>3],i&7,new_sp); print_ptrs(*old_sp++,*new_sp++,*was_oops++); } | |
| 703 tty->print_cr("--------|"); | |
| 704 for( int i1=0; i1<frame::memory_parameter_word_sp_offset-16; i1++ ) { | |
| 705 tty->print("argv pad|"PTR_FORMAT" ",new_sp); print_ptrs(*old_sp++,*new_sp++,*was_oops++); } | |
| 706 tty->print(" pad|"PTR_FORMAT" ",new_sp); print_ptrs(*old_sp++,*new_sp++,*was_oops++); | |
| 707 tty->print_cr("--------|"); | |
| 708 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; | |
| 709 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; | |
| 710 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; | |
| 711 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; | |
| 712 tty->print_cr(" FSR |"PTR_FORMAT" "PTR64_FORMAT" "PTR64_FORMAT,new_sp,*(jlong*)old_sp,*(jlong*)new_sp); | |
| 713 old_sp += incr; new_sp += incr; was_oops += incr; | |
| 714 // Skip the floats | |
| 715 tty->print_cr("--Float-|"PTR_FORMAT,new_sp); | |
| 716 tty->print_cr("---FP---|"); | |
| 717 old_sp += incr*32; new_sp += incr*32; was_oops += incr*32; | |
| 718 for( int i2=0; i2<16; i2++ ) { | |
| 719 tty->print("call %c%d |"PTR_FORMAT" ","LI"[i2>>3],i2&7,new_sp); print_ptrs(*old_sp++,*new_sp++,*was_oops++); } | |
| 720 tty->print_cr(""); | |
| 721 } | |
| 722 #endif // SPARC | |
| 723 #endif // PRODUCT | |
| 724 | |
| 725 | |
| 726 void SafepointSynchronize::handle_polling_page_exception(JavaThread *thread) { | |
| 727 assert(thread->is_Java_thread(), "polling reference encountered by VM thread"); | |
| 728 assert(thread->thread_state() == _thread_in_Java, "should come from Java code"); | |
| 729 assert(SafepointSynchronize::is_synchronizing(), "polling encountered outside safepoint synchronization"); | |
| 730 | |
| 731 // Uncomment this to get some serious before/after printing of the | |
| 732 // Sparc safepoint-blob frame structure. | |
| 733 /* | |
| 734 intptr_t* sp = thread->last_Java_sp(); | |
| 735 intptr_t stack_copy[150]; | |
| 736 for( int i=0; i<150; i++ ) stack_copy[i] = sp[i]; | |
| 737 bool was_oops[150]; | |
| 738 for( int i=0; i<150; i++ ) | |
| 739 was_oops[i] = stack_copy[i] ? ((oop)stack_copy[i])->is_oop() : false; | |
| 740 */ | |
| 741 | |
| 742 if (ShowSafepointMsgs) { | |
| 743 tty->print("handle_polling_page_exception: "); | |
| 744 } | |
| 745 | |
| 746 if (PrintSafepointStatistics) { | |
| 747 inc_page_trap_count(); | |
| 748 } | |
| 749 | |
| 750 ThreadSafepointState* state = thread->safepoint_state(); | |
| 751 | |
| 752 state->handle_polling_page_exception(); | |
| 753 // print_me(sp,stack_copy,was_oops); | |
| 754 } | |
| 755 | |
| 756 | |
| 757 void SafepointSynchronize::print_safepoint_timeout(SafepointTimeoutReason reason) { | |
| 758 if (!timeout_error_printed) { | |
| 759 timeout_error_printed = true; | |
| 760 // Print out the thread infor which didn't reach the safepoint for debugging | |
| 761 // purposes (useful when there are lots of threads in the debugger). | |
| 762 tty->print_cr(""); | |
| 763 tty->print_cr("# SafepointSynchronize::begin: Timeout detected:"); | |
| 764 if (reason == _spinning_timeout) { | |
| 765 tty->print_cr("# SafepointSynchronize::begin: Timed out while spinning to reach a safepoint."); | |
| 766 } else if (reason == _blocking_timeout) { | |
| 767 tty->print_cr("# SafepointSynchronize::begin: Timed out while waiting for threads to stop."); | |
| 768 } | |
| 769 | |
| 770 tty->print_cr("# SafepointSynchronize::begin: Threads which did not reach the safepoint:"); | |
| 771 ThreadSafepointState *cur_state; | |
| 772 ResourceMark rm; | |
| 773 for(JavaThread *cur_thread = Threads::first(); cur_thread; | |
| 774 cur_thread = cur_thread->next()) { | |
| 775 cur_state = cur_thread->safepoint_state(); | |
| 776 | |
| 777 if (cur_thread->thread_state() != _thread_blocked && | |
| 778 ((reason == _spinning_timeout && cur_state->is_running()) || | |
| 779 (reason == _blocking_timeout && !cur_state->has_called_back()))) { | |
| 780 tty->print("# "); | |
| 781 cur_thread->print(); | |
| 782 tty->print_cr(""); | |
| 783 } | |
| 784 } | |
| 785 tty->print_cr("# SafepointSynchronize::begin: (End of list)"); | |
| 786 } | |
| 787 | |
| 788 // To debug the long safepoint, specify both DieOnSafepointTimeout & | |
| 789 // ShowMessageBoxOnError. | |
| 790 if (DieOnSafepointTimeout) { | |
| 791 char msg[1024]; | |
| 792 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
|
793 sprintf(msg, "Safepoint sync time longer than " INTX_FORMAT "ms detected when executing %s.", |
| 0 | 794 SafepointTimeoutDelay, |
| 795 op != NULL ? op->name() : "no vm operation"); | |
| 796 fatal(msg); | |
| 797 } | |
| 798 } | |
| 799 | |
| 800 | |
| 801 // ------------------------------------------------------------------------------------------------------- | |
| 802 // Implementation of ThreadSafepointState | |
| 803 | |
| 804 ThreadSafepointState::ThreadSafepointState(JavaThread *thread) { | |
| 805 _thread = thread; | |
| 806 _type = _running; | |
| 807 _has_called_back = false; | |
| 808 _at_poll_safepoint = false; | |
| 809 } | |
| 810 | |
| 811 void ThreadSafepointState::create(JavaThread *thread) { | |
| 812 ThreadSafepointState *state = new ThreadSafepointState(thread); | |
| 813 thread->set_safepoint_state(state); | |
| 814 } | |
| 815 | |
| 816 void ThreadSafepointState::destroy(JavaThread *thread) { | |
| 817 if (thread->safepoint_state()) { | |
| 818 delete(thread->safepoint_state()); | |
| 819 thread->set_safepoint_state(NULL); | |
| 820 } | |
| 821 } | |
| 822 | |
| 823 void ThreadSafepointState::examine_state_of_thread() { | |
| 824 assert(is_running(), "better be running or just have hit safepoint poll"); | |
| 825 | |
| 826 JavaThreadState state = _thread->thread_state(); | |
| 827 | |
|
1727
da877bdc9000
6975006: assert(check.is_deoptimized_frame()) failed: missed deopt
never
parents:
1552
diff
changeset
|
828 // Save the state at the start of safepoint processing. |
|
da877bdc9000
6975006: assert(check.is_deoptimized_frame()) failed: missed deopt
never
parents:
1552
diff
changeset
|
829 _orig_thread_state = state; |
|
da877bdc9000
6975006: assert(check.is_deoptimized_frame()) failed: missed deopt
never
parents:
1552
diff
changeset
|
830 |
| 0 | 831 // Check for a thread that is suspended. Note that thread resume tries |
| 832 // to grab the Threads_lock which we own here, so a thread cannot be | |
| 833 // resumed during safepoint synchronization. | |
| 834 | |
| 979 | 835 // We check to see if this thread is suspended without locking to |
| 836 // avoid deadlocking with a third thread that is waiting for this | |
| 837 // thread to be suspended. The third thread can notice the safepoint | |
| 838 // that we're trying to start at the beginning of its SR_lock->wait() | |
| 839 // call. If that happens, then the third thread will block on the | |
| 840 // safepoint while still holding the underlying SR_lock. We won't be | |
| 841 // able to get the SR_lock and we'll deadlock. | |
| 842 // | |
| 843 // We don't need to grab the SR_lock here for two reasons: | |
| 844 // 1) The suspend flags are both volatile and are set with an | |
| 845 // Atomic::cmpxchg() call so we should see the suspended | |
| 846 // state right away. | |
| 847 // 2) We're being called from the safepoint polling loop; if | |
| 848 // we don't see the suspended state on this iteration, then | |
| 849 // we'll come around again. | |
| 850 // | |
| 851 bool is_suspended = _thread->is_ext_suspended(); | |
| 0 | 852 if (is_suspended) { |
| 853 roll_forward(_at_safepoint); | |
| 854 return; | |
| 855 } | |
| 856 | |
| 857 // Some JavaThread states have an initial safepoint state of | |
| 858 // running, but are actually at a safepoint. We will happily | |
| 859 // agree and update the safepoint state here. | |
| 860 if (SafepointSynchronize::safepoint_safe(_thread, state)) { | |
| 861 roll_forward(_at_safepoint); | |
| 862 return; | |
| 863 } | |
| 864 | |
| 865 if (state == _thread_in_vm) { | |
| 866 roll_forward(_call_back); | |
| 867 return; | |
| 868 } | |
| 869 | |
| 870 // All other thread states will continue to run until they | |
| 871 // transition and self-block in state _blocked | |
| 872 // Safepoint polling in compiled code causes the Java threads to do the same. | |
| 873 // Note: new threads may require a malloc so they must be allowed to finish | |
| 874 | |
| 875 assert(is_running(), "examine_state_of_thread on non-running thread"); | |
| 876 return; | |
| 877 } | |
| 878 | |
| 879 // Returns true is thread could not be rolled forward at present position. | |
| 880 void ThreadSafepointState::roll_forward(suspend_type type) { | |
| 881 _type = type; | |
| 882 | |
| 883 switch(_type) { | |
| 884 case _at_safepoint: | |
| 885 SafepointSynchronize::signal_thread_at_safepoint(); | |
| 886 break; | |
| 887 | |
| 888 case _call_back: | |
| 889 set_has_called_back(false); | |
| 890 break; | |
| 891 | |
| 892 case _running: | |
| 893 default: | |
| 894 ShouldNotReachHere(); | |
| 895 } | |
| 896 } | |
| 897 | |
| 898 void ThreadSafepointState::restart() { | |
| 899 switch(type()) { | |
| 900 case _at_safepoint: | |
| 901 case _call_back: | |
| 902 break; | |
| 903 | |
| 904 case _running: | |
| 905 default: | |
| 906 tty->print_cr("restart thread "INTPTR_FORMAT" with state %d", | |
| 907 _thread, _type); | |
| 908 _thread->print(); | |
| 909 ShouldNotReachHere(); | |
| 910 } | |
| 911 _type = _running; | |
| 912 set_has_called_back(false); | |
| 913 } | |
| 914 | |
| 915 | |
| 916 void ThreadSafepointState::print_on(outputStream *st) const { | |
| 917 const char *s; | |
| 918 | |
| 919 switch(_type) { | |
| 920 case _running : s = "_running"; break; | |
| 921 case _at_safepoint : s = "_at_safepoint"; break; | |
| 922 case _call_back : s = "_call_back"; break; | |
| 923 default: | |
| 924 ShouldNotReachHere(); | |
| 925 } | |
| 926 | |
| 927 st->print_cr("Thread: " INTPTR_FORMAT | |
| 928 " [0x%2x] State: %s _has_called_back %d _at_poll_safepoint %d", | |
| 929 _thread, _thread->osthread()->thread_id(), s, _has_called_back, | |
| 930 _at_poll_safepoint); | |
| 931 | |
| 932 _thread->print_thread_state_on(st); | |
| 933 } | |
| 934 | |
| 935 | |
| 936 // --------------------------------------------------------------------------------------------------------------------- | |
| 937 | |
| 938 // Block the thread at the safepoint poll or poll return. | |
| 939 void ThreadSafepointState::handle_polling_page_exception() { | |
| 940 | |
| 941 // Check state. block() will set thread state to thread_in_vm which will | |
| 942 // cause the safepoint state _type to become _call_back. | |
| 943 assert(type() == ThreadSafepointState::_running, | |
| 944 "polling page exception on thread not running state"); | |
| 945 | |
| 946 // Step 1: Find the nmethod from the return address | |
| 947 if (ShowSafepointMsgs && Verbose) { | |
| 948 tty->print_cr("Polling page exception at " INTPTR_FORMAT, thread()->saved_exception_pc()); | |
| 949 } | |
| 950 address real_return_addr = thread()->saved_exception_pc(); | |
| 951 | |
| 952 CodeBlob *cb = CodeCache::find_blob(real_return_addr); | |
| 953 assert(cb != NULL && cb->is_nmethod(), "return address should be in nmethod"); | |
| 954 nmethod* nm = (nmethod*)cb; | |
| 955 | |
| 956 // Find frame of caller | |
| 957 frame stub_fr = thread()->last_frame(); | |
| 958 CodeBlob* stub_cb = stub_fr.cb(); | |
| 959 assert(stub_cb->is_safepoint_stub(), "must be a safepoint stub"); | |
| 960 RegisterMap map(thread(), true); | |
| 961 frame caller_fr = stub_fr.sender(&map); | |
| 962 | |
| 963 // Should only be poll_return or poll | |
| 964 assert( nm->is_at_poll_or_poll_return(real_return_addr), "should not be at call" ); | |
| 965 | |
| 966 // This is a poll immediately before a return. The exception handling code | |
| 967 // has already had the effect of causing the return to occur, so the execution | |
| 968 // will continue immediately after the call. In addition, the oopmap at the | |
| 969 // return point does not mark the return value as an oop (if it is), so | |
| 970 // it needs a handle here to be updated. | |
| 971 if( nm->is_at_poll_return(real_return_addr) ) { | |
| 972 // See if return type is an oop. | |
| 973 bool return_oop = nm->method()->is_returning_oop(); | |
| 974 Handle return_value; | |
| 975 if (return_oop) { | |
| 976 // The oop result has been saved on the stack together with all | |
| 977 // the other registers. In order to preserve it over GCs we need | |
| 978 // to keep it in a handle. | |
| 979 oop result = caller_fr.saved_oop_result(&map); | |
| 980 assert(result == NULL || result->is_oop(), "must be oop"); | |
| 981 return_value = Handle(thread(), result); | |
| 982 assert(Universe::heap()->is_in_or_null(result), "must be heap pointer"); | |
| 983 } | |
| 984 | |
| 985 // Block the thread | |
| 986 SafepointSynchronize::block(thread()); | |
| 987 | |
| 988 // restore oop result, if any | |
| 989 if (return_oop) { | |
| 990 caller_fr.set_saved_oop_result(&map, return_value()); | |
| 991 } | |
| 992 } | |
| 993 | |
| 994 // This is a safepoint poll. Verify the return address and block. | |
| 995 else { | |
| 996 set_at_poll_safepoint(true); | |
| 997 | |
| 998 // verify the blob built the "return address" correctly | |
| 999 assert(real_return_addr == caller_fr.pc(), "must match"); | |
| 1000 | |
| 1001 // Block the thread | |
| 1002 SafepointSynchronize::block(thread()); | |
| 1003 set_at_poll_safepoint(false); | |
| 1004 | |
| 1005 // If we have a pending async exception deoptimize the frame | |
| 1006 // as otherwise we may never deliver it. | |
| 1007 if (thread()->has_async_condition()) { | |
| 1008 ThreadInVMfromJavaNoAsyncException __tiv(thread()); | |
|
1905
ce6848d0666d
6968367: can_post_on_exceptions is still using VM_DeoptimizeFrame in some places
never
parents:
1783
diff
changeset
|
1009 Deoptimization::deoptimize_frame(thread(), caller_fr.id()); |
| 0 | 1010 } |
| 1011 | |
| 1012 // If an exception has been installed we must check for a pending deoptimization | |
| 1013 // Deoptimize frame if exception has been thrown. | |
| 1014 | |
| 1015 if (thread()->has_pending_exception() ) { | |
| 1016 RegisterMap map(thread(), true); | |
| 1017 frame caller_fr = stub_fr.sender(&map); | |
| 1018 if (caller_fr.is_deoptimized_frame()) { | |
| 1019 // The exception patch will destroy registers that are still | |
| 1020 // live and will be needed during deoptimization. Defer the | |
| 1021 // Async exception should have defered the exception until the | |
| 1022 // next safepoint which will be detected when we get into | |
| 1023 // the interpreter so if we have an exception now things | |
| 1024 // are messed up. | |
| 1025 | |
| 1026 fatal("Exception installed and deoptimization is pending"); | |
| 1027 } | |
| 1028 } | |
| 1029 } | |
| 1030 } | |
| 1031 | |
| 1032 | |
| 1033 // | |
| 1034 // Statistics & Instrumentations | |
| 1035 // | |
| 1036 SafepointSynchronize::SafepointStats* SafepointSynchronize::_safepoint_stats = NULL; | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1037 jlong SafepointSynchronize::_safepoint_begin_time = 0; |
| 0 | 1038 int SafepointSynchronize::_cur_stat_index = 0; |
| 1039 julong SafepointSynchronize::_safepoint_reasons[VM_Operation::VMOp_Terminating]; | |
| 1040 julong SafepointSynchronize::_coalesced_vmop_count = 0; | |
| 1041 jlong SafepointSynchronize::_max_sync_time = 0; | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1042 jlong SafepointSynchronize::_max_vmop_time = 0; |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1043 float SafepointSynchronize::_ts_of_current_safepoint = 0.0f; |
| 0 | 1044 |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1045 static jlong cleanup_end_time = 0; |
| 0 | 1046 static bool need_to_track_page_armed_status = false; |
| 1047 static bool init_done = false; | |
| 1048 | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1049 // Helper method to print the header. |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1050 static void print_header() { |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1051 tty->print(" vmop " |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1052 "[threads: total initially_running wait_to_block] "); |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1053 tty->print("[time: spin block sync cleanup vmop] "); |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1054 |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1055 // 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
|
1056 if (need_to_track_page_armed_status) { |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1057 tty->print("page_armed "); |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1058 } |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1059 |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1060 tty->print_cr("page_trap_count"); |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1061 } |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1062 |
| 0 | 1063 void SafepointSynchronize::deferred_initialize_stat() { |
| 1064 if (init_done) return; | |
| 1065 | |
| 1066 if (PrintSafepointStatisticsCount <= 0) { | |
| 1067 fatal("Wrong PrintSafepointStatisticsCount"); | |
| 1068 } | |
| 1069 | |
| 1070 // If PrintSafepointStatisticsTimeout is specified, the statistics data will | |
| 1071 // be printed right away, in which case, _safepoint_stats will regress to | |
| 1072 // a single element array. Otherwise, it is a circular ring buffer with default | |
| 1073 // size of PrintSafepointStatisticsCount. | |
| 1074 int stats_array_size; | |
| 1075 if (PrintSafepointStatisticsTimeout > 0) { | |
| 1076 stats_array_size = 1; | |
| 1077 PrintSafepointStatistics = true; | |
| 1078 } else { | |
| 1079 stats_array_size = PrintSafepointStatisticsCount; | |
| 1080 } | |
| 1081 _safepoint_stats = (SafepointStats*)os::malloc(stats_array_size | |
| 1082 * sizeof(SafepointStats)); | |
| 1083 guarantee(_safepoint_stats != NULL, | |
| 1084 "not enough memory for safepoint instrumentation data"); | |
| 1085 | |
| 1086 if (UseCompilerSafepoints && DeferPollingPageLoopCount >= 0) { | |
| 1087 need_to_track_page_armed_status = true; | |
| 1088 } | |
| 1089 init_done = true; | |
| 1090 } | |
| 1091 | |
| 1092 void SafepointSynchronize::begin_statistics(int nof_threads, int nof_running) { | |
| 1003 | 1093 assert(init_done, "safepoint statistics array hasn't been initialized"); |
| 0 | 1094 SafepointStats *spstat = &_safepoint_stats[_cur_stat_index]; |
| 1095 | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1096 spstat->_time_stamp = _ts_of_current_safepoint; |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1097 |
| 0 | 1098 VM_Operation *op = VMThread::vm_operation(); |
| 1099 spstat->_vmop_type = (op != NULL ? op->type() : -1); | |
| 1100 if (op != NULL) { | |
| 1101 _safepoint_reasons[spstat->_vmop_type]++; | |
| 1102 } | |
| 1103 | |
| 1104 spstat->_nof_total_threads = nof_threads; | |
| 1105 spstat->_nof_initial_running_threads = nof_running; | |
| 1106 spstat->_nof_threads_hit_page_trap = 0; | |
| 1107 | |
| 1108 // Records the start time of spinning. The real time spent on spinning | |
| 1109 // will be adjusted when spin is done. Same trick is applied for time | |
| 1110 // spent on waiting for threads to block. | |
| 1111 if (nof_running != 0) { | |
| 1112 spstat->_time_to_spin = os::javaTimeNanos(); | |
| 1113 } else { | |
| 1114 spstat->_time_to_spin = 0; | |
| 1115 } | |
| 1116 } | |
| 1117 | |
| 1118 void SafepointSynchronize::update_statistics_on_spin_end() { | |
| 1119 SafepointStats *spstat = &_safepoint_stats[_cur_stat_index]; | |
| 1120 | |
| 1121 jlong cur_time = os::javaTimeNanos(); | |
| 1122 | |
| 1123 spstat->_nof_threads_wait_to_block = _waiting_to_block; | |
| 1124 if (spstat->_nof_initial_running_threads != 0) { | |
| 1125 spstat->_time_to_spin = cur_time - spstat->_time_to_spin; | |
| 1126 } | |
| 1127 | |
| 1128 if (need_to_track_page_armed_status) { | |
| 1129 spstat->_page_armed = (PageArmed == 1); | |
| 1130 } | |
| 1131 | |
| 1132 // Records the start time of waiting for to block. Updated when block is done. | |
| 1133 if (_waiting_to_block != 0) { | |
| 1134 spstat->_time_to_wait_to_block = cur_time; | |
| 1135 } else { | |
| 1136 spstat->_time_to_wait_to_block = 0; | |
| 1137 } | |
| 1138 } | |
| 1139 | |
| 1140 void SafepointSynchronize::update_statistics_on_sync_end(jlong end_time) { | |
| 1141 SafepointStats *spstat = &_safepoint_stats[_cur_stat_index]; | |
| 1142 | |
| 1143 if (spstat->_nof_threads_wait_to_block != 0) { | |
| 1144 spstat->_time_to_wait_to_block = end_time - | |
| 1145 spstat->_time_to_wait_to_block; | |
| 1146 } | |
| 1147 | |
| 1148 // Records the end time of sync which will be used to calculate the total | |
| 1149 // vm operation time. Again, the real time spending in syncing will be deducted | |
| 1150 // 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
|
1151 spstat->_time_to_sync = end_time - _safepoint_begin_time; |
| 0 | 1152 if (spstat->_time_to_sync > _max_sync_time) { |
| 1153 _max_sync_time = spstat->_time_to_sync; | |
| 1154 } | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1155 |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1156 spstat->_time_to_do_cleanups = end_time; |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1157 } |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1158 |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1159 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
|
1160 SafepointStats *spstat = &_safepoint_stats[_cur_stat_index]; |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1161 |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1162 // Record how long spent in cleanup tasks. |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1163 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
|
1164 |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1165 cleanup_end_time = end_time; |
| 0 | 1166 } |
| 1167 | |
| 1168 void SafepointSynchronize::end_statistics(jlong vmop_end_time) { | |
| 1169 SafepointStats *spstat = &_safepoint_stats[_cur_stat_index]; | |
| 1170 | |
| 1171 // Update the vm operation time. | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1172 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
|
1173 if (spstat->_time_to_exec_vmop > _max_vmop_time) { |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1174 _max_vmop_time = spstat->_time_to_exec_vmop; |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1175 } |
| 0 | 1176 // Only the sync time longer than the specified |
| 1177 // PrintSafepointStatisticsTimeout will be printed out right away. | |
| 1178 // By default, it is -1 meaning all samples will be put into the list. | |
| 1179 if ( PrintSafepointStatisticsTimeout > 0) { | |
| 1180 if (spstat->_time_to_sync > PrintSafepointStatisticsTimeout * MICROUNITS) { | |
| 1181 print_statistics(); | |
| 1182 } | |
| 1183 } else { | |
| 1184 // The safepoint statistics will be printed out when the _safepoin_stats | |
| 1185 // array fills up. | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1186 if (_cur_stat_index == PrintSafepointStatisticsCount - 1) { |
| 0 | 1187 print_statistics(); |
| 1188 _cur_stat_index = 0; | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1189 } else { |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1190 _cur_stat_index++; |
| 0 | 1191 } |
| 1192 } | |
| 1193 } | |
| 1194 | |
| 1195 void SafepointSynchronize::print_statistics() { | |
| 1196 SafepointStats* sstats = _safepoint_stats; | |
| 1197 | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1198 for (int index = 0; index <= _cur_stat_index; index++) { |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1199 if (index % 30 == 0) { |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1200 print_header(); |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1201 } |
| 0 | 1202 sstats = &_safepoint_stats[index]; |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1203 tty->print("%.3f: ", sstats->_time_stamp); |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1204 tty->print("%-26s [" |
| 0 | 1205 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
|
1206 " ] ", |
| 0 | 1207 sstats->_vmop_type == -1 ? "no vm operation" : |
| 1208 VM_Operation::name(sstats->_vmop_type), | |
| 1209 sstats->_nof_total_threads, | |
| 1210 sstats->_nof_initial_running_threads, | |
| 1211 sstats->_nof_threads_wait_to_block); | |
| 1212 // "/ 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
|
1213 tty->print(" [" |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1214 INT64_FORMAT_W(6)INT64_FORMAT_W(6) |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1215 INT64_FORMAT_W(6)INT64_FORMAT_W(6) |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1216 INT64_FORMAT_W(6)" ] ", |
| 0 | 1217 sstats->_time_to_spin / MICROUNITS, |
| 1218 sstats->_time_to_wait_to_block / MICROUNITS, | |
| 1219 sstats->_time_to_sync / MICROUNITS, | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1220 sstats->_time_to_do_cleanups / MICROUNITS, |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1221 sstats->_time_to_exec_vmop / MICROUNITS); |
| 0 | 1222 |
| 1223 if (need_to_track_page_armed_status) { | |
| 1224 tty->print(INT32_FORMAT" ", sstats->_page_armed); | |
| 1225 } | |
| 1226 tty->print_cr(INT32_FORMAT" ", sstats->_nof_threads_hit_page_trap); | |
| 1227 } | |
| 1228 } | |
| 1229 | |
| 1230 // This method will be called when VM exits. It will first call | |
| 1231 // print_statistics to print out the rest of the sampling. Then | |
| 1232 // it tries to summarize the sampling. | |
| 1233 void SafepointSynchronize::print_stat_on_exit() { | |
| 1234 if (_safepoint_stats == NULL) return; | |
| 1235 | |
| 1236 SafepointStats *spstat = &_safepoint_stats[_cur_stat_index]; | |
| 1237 | |
| 1238 // During VM exit, end_statistics may not get called and in that | |
| 1239 // case, if the sync time is less than PrintSafepointStatisticsTimeout, | |
| 1240 // don't print it out. | |
| 1241 // Approximate the vm op time. | |
| 1242 _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
|
1243 os::javaTimeNanos() - cleanup_end_time; |
| 0 | 1244 |
| 1245 if ( PrintSafepointStatisticsTimeout < 0 || | |
| 1246 spstat->_time_to_sync > PrintSafepointStatisticsTimeout * MICROUNITS) { | |
| 1247 print_statistics(); | |
| 1248 } | |
| 1249 tty->print_cr(""); | |
| 1250 | |
| 1251 // Print out polling page sampling status. | |
| 1252 if (!need_to_track_page_armed_status) { | |
| 1253 if (UseCompilerSafepoints) { | |
| 1254 tty->print_cr("Polling page always armed"); | |
| 1255 } | |
| 1256 } else { | |
| 1257 tty->print_cr("Defer polling page loop count = %d\n", | |
| 1258 DeferPollingPageLoopCount); | |
| 1259 } | |
| 1260 | |
| 1261 for (int index = 0; index < VM_Operation::VMOp_Terminating; index++) { | |
| 1262 if (_safepoint_reasons[index] != 0) { | |
| 1263 tty->print_cr("%-26s"UINT64_FORMAT_W(10), VM_Operation::name(index), | |
| 1264 _safepoint_reasons[index]); | |
| 1265 } | |
| 1266 } | |
| 1267 | |
| 1268 tty->print_cr(UINT64_FORMAT_W(5)" VM operations coalesced during safepoint", | |
| 1269 _coalesced_vmop_count); | |
| 1270 tty->print_cr("Maximum sync time "INT64_FORMAT_W(5)" ms", | |
| 1271 _max_sync_time / MICROUNITS); | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1272 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
|
1273 INT64_FORMAT_W(5)" ms", |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
1003
diff
changeset
|
1274 _max_vmop_time / MICROUNITS); |
| 0 | 1275 } |
| 1276 | |
| 1277 // ------------------------------------------------------------------------------------------------ | |
| 1278 // Non-product code | |
| 1279 | |
| 1280 #ifndef PRODUCT | |
| 1281 | |
| 1282 void SafepointSynchronize::print_state() { | |
| 1283 if (_state == _not_synchronized) { | |
| 1284 tty->print_cr("not synchronized"); | |
| 1285 } else if (_state == _synchronizing || _state == _synchronized) { | |
| 1286 tty->print_cr("State: %s", (_state == _synchronizing) ? "synchronizing" : | |
| 1287 "synchronized"); | |
| 1288 | |
| 1289 for(JavaThread *cur = Threads::first(); cur; cur = cur->next()) { | |
| 1290 cur->safepoint_state()->print(); | |
| 1291 } | |
| 1292 } | |
| 1293 } | |
| 1294 | |
| 1295 void SafepointSynchronize::safepoint_msg(const char* format, ...) { | |
| 1296 if (ShowSafepointMsgs) { | |
| 1297 va_list ap; | |
| 1298 va_start(ap, format); | |
| 1299 tty->vprint_cr(format, ap); | |
| 1300 va_end(ap); | |
| 1301 } | |
| 1302 } | |
| 1303 | |
| 1304 #endif // !PRODUCT |