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