safepoint.cpp revision 1472
4632N/A * Copyright (c) 1997, 2009, Oracle and/or its affiliates. All rights reserved. 4632N/A * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4632N/A * This code is free software; you can redistribute it and/or modify it 4632N/A * under the terms of the GNU General Public License version 2 only, as 4632N/A * published by the Free Software Foundation. 4632N/A * This code is distributed in the hope that it will be useful, but WITHOUT 4632N/A * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 4632N/A * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 4632N/A * version 2 for more details (a copy is included in the LICENSE file that 4632N/A * You should have received a copy of the GNU General Public License version 4632N/A * 2 along with this work; if not, write to the Free Software Foundation, 4632N/A * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 4632N/A * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 4632N/A#
include "incls/_precompiled.incl" 4632N/A// -------------------------------------------------------------------------------------------------- 4632N/Astatic volatile int PageArmed = 0 ;
// safepoint polling page is RO|RW vs PROT_NONE 4632N/A// Roll all threads forward to a safepoint and suspend them all 4632N/A // In the future we should investigate whether CMS can use the 4632N/A // more-general mechanism below. DLD (01/05). 4632N/A // By getting the Threads_lock, we assure that no threads are about to start or 4632N/A // exit. It is released again in SafepointSynchronize::end(). 4632N/A // Set number of threads to wait for, before we initiate the callbacks 4632N/A // Save the starting time, so that it can be compared to see if this has taken 4632N/A // PrintSafepointStatisticsTimeout can be specified separately. When 4632N/A // specified, PrintSafepointStatistics will be set to true in 4632N/A // deferred_initialize_stat method. The initialization has to be done 4632N/A // early enough to avoid any races. See bug 6880029 for details. 4632N/A // Begin the process of bringing the system to a safepoint. 4632N/A // Java threads can be in several different states and are 4632N/A // stopped by different mechanisms: 4632N/A // The interpeter dispatch table is changed to force it to 4632N/A // check for a safepoint condition between bytecodes. 4632N/A // 2. Running in native code 4632N/A // When returning from the native code, a Java thread must check 4632N/A // the safepoint _state to see if we must block. If the 4632N/A // VM thread sees a Java thread in native, it does 4632N/A // not wait for this thread to block. The order of the memory 4632N/A // writes and reads of both the safepoint state and the Java 4632N/A // threads state is critical. In order to guarantee that the 4632N/A // memory writes are serialized with respect to each other, 4632N/A // the VM thread issues a memory barrier instruction 5037N/A // (on MP systems). In order to avoid the overhead of issuing 5037N/A // a memory barrier for each Java thread making native calls, each Java 5037N/A // thread performs a write to a single memory page after changing 5037N/A // the thread state. The VM thread performs a sequence of 5037N/A // mprotect OS calls which forces all previous writes from all 5037N/A // Java threads to be serialized. This is done in the 5037N/A // os::serialize_thread_states() call. This has proven to be 5037N/A // much more efficient than executing a membar instruction 4632N/A // on every call to native code. 4632N/A // 3. Running compiled Code 4632N/A // Compiled code reads a global (Safepoint Polling) page that 4632N/A // is set to fault if we are trying to get to a safepoint. 4632N/A // A thread which is blocked will not be allowed to return from the 4632N/A // block condition until the safepoint operation is complete. 4632N/A // 5. In VM or Transitioning between states 4632N/A // If a Java thread is currently running in the VM or transitioning 4632N/A // between states, the safepointing code will wait for the thread to 4632N/A // block itself when it attempts transitions to a new state. 4632N/A // Flush all thread states to memory 4632N/A // Make interpreter safepoint aware 4632N/A // Make polling safepoint aware 4632N/A // Consider using active_processor_count() ... but that call is expensive. 4632N/A // Iterate through all threads until it have been determined how to stop them all at a safepoint 4632N/A // consider adjusting steps downward: 4632N/A // steps = MIN(steps, 2000-100) 4632N/A // if (iterations != 0) steps -= NNN 4632N/A // Check for if it takes to long 4632N/A // Spin to avoid context switching. 4632N/A // There's a tension between allowing the mutators to run (and rendezvous) 4632N/A // vs spinning. As the VM thread spins, wasting cycles, it consumes CPU that 4632N/A // a mutator might otherwise use profitably to reach a safepoint. Excessive 4632N/A // spinning by the VM thread on a saturated system can increase rendezvous latency. 4632N/A // Blocking or yielding incur their own penalties in the form of context switching 4632N/A // and the resultant loss of $ residency. 4632N/A // Further complicating matters is that yield() does not work as naively expected 4632N/A // on many platforms -- yield() does not guarantee that any other ready threads 4632N/A // will run. As such we revert yield_all() after some number of iterations. 4632N/A // Yield_all() is implemented as a short unconditional sleep on some platforms. 4632N/A // Typical operating systems round a "short" sleep period up to 10 msecs, so sleeping 4632N/A // can actually increase the time it takes the VM thread to detect that a system-wide 4632N/A // stop-the-world safepoint has been reached. In a pathological scenario such as that 4632N/A // described in CR6415670 the VMthread may sleep just before the mutator(s) become safe. 4632N/A // In that case the mutators will be stalled waiting for the safepoint to complete and the 4632N/A // the VMthread will be sleeping, waiting for the mutators to rendezvous. The VMthread 4632N/A // will eventually wake up and detect that all mutators are safe, at which point 4632N/A // we'll again make progress. 4632N/A // Beware too that that the VMThread typically runs at elevated priority. 4632N/A // Its default priority is higher than the default mutator priority. 4632N/A // Obviously, this complicates spinning. 4632N/A // Note too that on Windows XP SwitchThreadTo() has quite different behavior than Sleep(0). 4632N/A // Sleep(0) will _not yield to lower priority threads, while SwitchThreadTo() will. 4632N/A // 1. Modify the safepoint scheme to avoid potentally unbounded spinning. 4632N/A // This is tricky as the path used by a thread exiting the JVM (say on 4632N/A // on JNI call-out) simply stores into its state field. The burden 4632N/A // is placed on the VM thread, which must poll (spin). 4632N/A // 2. Find something useful to do while spinning. If the safepoint is GC-related 4632N/A // we might aggressively scan the stacks of threads that are already safe. 4632N/A // 3. Use Solaris schedctl to examine the state of the still-running mutators. 4632N/A // If all the mutators are ONPROC there's no reason to sleep or yield. 4632N/A // 4. YieldTo() any still-running mutators that are ready but OFFPROC. 4632N/A // 5. Check system saturation. If the system is not fully saturated then 4632N/A // 6. As still-running mutators rendezvous they could unpark the sleeping 4632N/A // VMthread. This works well for still-running mutators that become 4632N/A // safe. The VMthread must still poll for mutators that call-out. 4632N/A // 7. Drive the policy on time-since-begin instead of iterations. 4632N/A // 8. Consider making the spin duration a function of the # of CPUs: 4632N/A // Spin = (((ncpus-1) * M) + K) + F(still_running) 4632N/A // Alternately, instead of counting iterations of the outer loop 4632N/A // we could count the # of threads visited in the inner loop, above. 4632N/A // 9. On windows consider using the return value from SwitchThreadTo() 4632N/A // Instead of (ncpus > 1) consider either (still_running < (ncpus + EPSILON)) or 4632N/A // ((still_running + _waiting_to_block - TryingToBlock)) < ncpus) 4632N/A // Alternately, the VM thread could transiently depress its scheduling priority or 4632N/A // transiently increase the priority of the tardy mutator(s). 4632N/A // wait until all threads are stopped 4632N/A // If there is no remaining time, then there is an error 4632N/A // Call stuff that needs to be run when a safepoint is just about to be completed 4632N/A // Record how much time spend on the above cleanup tasks 4632N/A// Wake up all threads, so they are ready to resume execution after the safepoint 4632N/A// operation has been carried out 4632N/A // memory fence isn't required here since an odd _safepoint_counter 4632N/A // value can do no harm and a fence is issued below anyway. 4632N/A // A pending_exception cannot be installed during a safepoint. The threads 4632N/A // may install an async exception after they come back from a safepoint into 4632N/A // pending_exception after they unblock. But that should happen later. 4632N/A "safepoint installed a pending exception");
4632N/A // Make polling safepoint aware 4632N/A // Remove safepoint check from interpreter 4632N/A // Set to not synchronized, so the threads will not go into the signal_thread_blocked method 4632N/A // when they get restarted. 4632N/A // A problem occurring on Solaris is when attempting to restart threads 4632N/A // the first #cpus - 1 go well, but then the VMThread is preempted when we get 4632N/A // to the next one (since it has been running the longest). We then have 4632N/A // to wait for a cpu to become available before we can continue restarting 4632N/A // FIXME: This causes the performance of the VM to degrade when active and with 4632N/A // large numbers of threads. Apparently this is due to the synchronous nature 4632N/A // TODO-FIXME: the comments above are vestigial and no longer apply. 4632N/A // Furthermore, using solaris' schedctl in this particular context confers no benefit 4632N/A // blocked in signal_thread_blocked 4632N/A // If there are any concurrent GC threads resume them. 4632N/A // record this time so VMThread can keep track how much time has elasped 4632N/A // Need a safepoint if some inline cache buffers is non-empty 4632N/A // This operation is going to be performed only at the end of a safepoint 4632N/A // and hence GC's will not be going on, all Java mutators are suspended 4632N/A // at this point and hence SystemDictionary_lock is also not needed. 4632N/A// Various cleaning tasks that should be done periodically at safepoints 4632N/A // native threads are safe if they have no java stack or have walkable stack 4632N/A // blocked threads should have already have walkable stack 4632N/A// ------------------------------------------------------------------------------------------------------- 4632N/A// Implementation of Safepoint callback point 4632N/A // Threads shouldn't block if they are in the middle of printing, but... 4632N/A // Only bail from the block() call if the thread is gone from the 4632N/A // thread list; starting to exit should still block. 4632N/A // block current thread if we come here from native code when VM is gone 4632N/A // Check that we have a valid thread_state at this point 4632N/A // We are highly likely to block on the Safepoint_lock. In order to avoid blocking in this case, 4632N/A // we pretend we are still in the VM. 4632N/A // We will always be holding the Safepoint_lock when we are examine the state 4632N/A // of a thread. Hence, the instructions between the Safepoint_lock->lock() and 4632N/A // Safepoint_lock->unlock() are happening atomic with regards to the safepoint code 4632N/A // Decrement the number of threads to wait for and signal vm thread 4632N/A // Consider (_waiting_to_block < 2) to pipeline the wakeup of the VM thread 4632N/A // We transition the thread to state _thread_blocked here, but 4632N/A // we can't do our usual check for external suspension and then 4632N/A // self-suspend after the lock_without_safepoint_check() call 4632N/A // below because we are often called during transitions while 4632N/A // we hold different locks. That would leave us suspended while 4632N/A // holding a resource which results in deadlocks. 4632N/A // We now try to acquire the threads lock. Since this lock is hold by the VM thread during 4632N/A // the entire safepoint, the threads will all line up here during the safepoint. 4632N/A // restore original state. This is important if the thread comes from compiled code, so it 4632N/A // will continue to execute with the _thread_in_Java state. 4632N/A "Should have called back to the VM before blocking.");
4632N/A // We transition the thread to state _thread_blocked here, but 4632N/A // we can't do our usual check for external suspension and then 4632N/A // self-suspend after the lock_without_safepoint_check() call 4632N/A // below because we are often called during transitions while 4632N/A // we hold different locks. That would leave us suspended while 4632N/A // holding a resource which results in deadlocks. 4632N/A // It is not safe to suspend a thread if we discover it is in _thread_in_native_trans. Hence, 4632N/A // the safepoint code might still be waiting for it to block. We need to change the state here, 4632N/A // so it can see that it is at a safepoint. 4632N/A // Block until the safepoint operation is completed. 4632N/A // Check for pending. async. exceptions or suspends - except if the 4632N/A // thread was blocked inside the VM. has_special_runtime_exit_condition() 4632N/A // is called last since it grabs a lock and we only want to do that when 4632N/A // Note: we never deliver an async exception at a polling point as the 4632N/A // compiler may not have an exception handler for it. The polling 4632N/A // code will notice the async and deoptimize and the exception will 4632N/A // be delivered. (Polling at a return point is ok though). Sure is 4632N/A // a lot of bother for a deprecated feature... 4632N/A // We don't deliver an async exception if the thread state is 4632N/A // _thread_in_native_trans so JNI functions won't be called with 4632N/A // a surprising pending exception. If the thread state is going back to java, 4632N/A // async exception is checked in check_special_condition_for_native_trans(). 4632N/A// ------------------------------------------------------------------------------------------------------ 4632N/A tty->
print_cr(
"--------+------address-----+------before-----------+-------after----------+");
4632N/A const int incr =
1;
// Increment to skip a long, in units of intptr_t 4632N/A tty->
print_cr(
"--------+--address-+------before-----------+-------after----------+");
4632N/A const int incr =
2;
// Increment to skip a long, in units of intptr_t 4632N/A for(
int i=0; i<
16; i++ ) {
4632N/A // Sparc safepoint-blob frame structure. 4632N/A intptr_t* sp = thread->last_Java_sp(); 4632N/A for( int i=0; i<150; i++ ) stack_copy[i] = sp[i]; 4632N/A was_oops[i] = stack_copy[i] ? ((oop)stack_copy[i])->is_oop() : false; 4632N/A // print_me(sp,stack_copy,was_oops); 4632N/A // Print out the thread infor which didn't reach the safepoint for debugging 4632N/A // purposes (useful when there are lots of threads in the debugger). 4632N/A tty->
print_cr(
"# SafepointSynchronize::begin: Timed out while spinning to reach a safepoint.");
4632N/A tty->
print_cr(
"# SafepointSynchronize::begin: Timed out while waiting for threads to stop.");
4632N/A tty->
print_cr(
"# SafepointSynchronize::begin: Threads which did not reach the safepoint:");
4632N/A // To debug the long safepoint, specify both DieOnSafepointTimeout & // ------------------------------------------------------------------------------------------------------- // Implementation of ThreadSafepointState // Check for a thread that is suspended. Note that thread resume tries // to grab the Threads_lock which we own here, so a thread cannot be // resumed during safepoint synchronization. // We check to see if this thread is suspended without locking to // avoid deadlocking with a third thread that is waiting for this // thread to be suspended. The third thread can notice the safepoint // that we're trying to start at the beginning of its SR_lock->wait() // call. If that happens, then the third thread will block on the // safepoint while still holding the underlying SR_lock. We won't be // able to get the SR_lock and we'll deadlock. // We don't need to grab the SR_lock here for two reasons: // 1) The suspend flags are both volatile and are set with an // Atomic::cmpxchg() call so we should see the suspended // 2) We're being called from the safepoint polling loop; if // we don't see the suspended state on this iteration, then // we'll come around again. // Some JavaThread states have an initial safepoint state of // running, but are actually at a safepoint. We will happily // agree and update the safepoint state here. // All other thread states will continue to run until they // transition and self-block in state _blocked // Safepoint polling in compiled code causes the Java threads to do the same. // Note: new threads may require a malloc so they must be allowed to finish // Returns true is thread could not be rolled forward at present position. " [0x%2x] State: %s _has_called_back %d _at_poll_safepoint %d",
// --------------------------------------------------------------------------------------------------------------------- // Block the thread at the safepoint poll or poll return. // Check state. block() will set thread state to thread_in_vm which will // cause the safepoint state _type to become _call_back. "polling page exception on thread not running state");
// Step 1: Find the nmethod from the return address // Should only be poll_return or poll // This is a poll immediately before a return. The exception handling code // has already had the effect of causing the return to occur, so the execution // will continue immediately after the call. In addition, the oopmap at the // return point does not mark the return value as an oop (if it is), so // it needs a handle here to be updated. // See if return type is an oop. // The oop result has been saved on the stack together with all // the other registers. In order to preserve it over GCs we need // to keep it in a handle. // restore oop result, if any // This is a safepoint poll. Verify the return address and block. // verify the blob built the "return address" correctly // If we have a pending async exception deoptimize the frame // as otherwise we may never deliver it. // If an exception has been installed we must check for a pending deoptimization // Deoptimize frame if exception has been thrown. // The exception patch will destroy registers that are still // live and will be needed during deoptimization. Defer the // Async exception should have defered the exception until the // next safepoint which will be detected when we get into // the interpreter so if we have an exception now things fatal(
"Exception installed and deoptimization is pending");
// Statistics & Instrumentations // Helper method to print the header. "[threads: total initially_running wait_to_block] ");
tty->
print(
"[time: spin block sync cleanup vmop] ");
// no page armed status printed out if it is always armed. fatal(
"Wrong PrintSafepointStatisticsCount");
// If PrintSafepointStatisticsTimeout is specified, the statistics data will // be printed right away, in which case, _safepoint_stats will regress to // a single element array. Otherwise, it is a circular ring buffer with default // size of PrintSafepointStatisticsCount. "not enough memory for safepoint instrumentation data");
// Records the start time of spinning. The real time spent on spinning // will be adjusted when spin is done. Same trick is applied for time // spent on waiting for threads to block. // Records the start time of waiting for to block. Updated when block is done. // Records the end time of sync which will be used to calculate the total // vm operation time. Again, the real time spending in syncing will be deducted // from the start of the sync time later when end_statistics is called. // Record how long spent in cleanup tasks. // Update the vm operation time. // Only the sync time longer than the specified // PrintSafepointStatisticsTimeout will be printed out right away. // By default, it is -1 meaning all samples will be put into the list. // The safepoint statistics will be printed out when the _safepoin_stats // "/ MICROUNITS " is to convert the unit from nanos to millis. // This method will be called when VM exits. It will first call // print_statistics to print out the rest of the sampling. Then // it tries to summarize the sampling. // During VM exit, end_statistics may not get called and in that // case, if the sync time is less than PrintSafepointStatisticsTimeout, // Approximate the vm op time. // Print out polling page sampling status. tty->
print_cr(
"Maximum vm operation time (except for Exit VM operation) " // ------------------------------------------------------------------------------------------------