jdk-sandbox: comparison hotspot/src/share/vm/runtime/sweeper.cpp

equal deleted inserted replaced

-:34c4ef11dbed
+:e8d9ff82ec62
 int       NMethodSweeper::_invocations = 0;  // No. of invocations left until we are completed with this pass
 jint      NMethodSweeper::_locked_seen = 0;
 jint      NMethodSweeper::_not_entrant_seen_on_stack = 0;
 bool      NMethodSweeper::_rescan = false;
+bool      NMethodSweeper::_do_sweep = false;
+jint      NMethodSweeper::_sweep_started = 0;
 bool      NMethodSweeper::_was_full = false;
 jint      NMethodSweeper::_advise_to_sweep = 0;
 jlong     NMethodSweeper::_last_was_full = 0;
 uint      NMethodSweeper::_highest_marked = 0;
 long      NMethodSweeper::_was_full_traversal = 0;
 }
 }
 };
 static MarkActivationClosure mark_activation_closure;
-void NMethodSweeper::sweep() {
+void NMethodSweeper::scan_stacks() {
 assert(SafepointSynchronize::is_at_safepoint(), "must be executed at a safepoint");
 if (!MethodFlushing) return;
+_do_sweep = true;
 // No need to synchronize access, since this is always executed at a
 // safepoint.  If we aren't in the middle of scan and a rescan
-// hasn't been requested then just return.
+// hasn't been requested then just return. If UseCodeCacheFlushing is on and
-if (_current == NULL && !_rescan) return;
+// code cache flushing is in progress, don't skip sweeping to help make progress
+// clearing space in the code cache.
+if ((_current == NULL && !_rescan) && !(UseCodeCacheFlushing && !CompileBroker::should_compile_new_jobs())) {
+_do_sweep = false;
+return;
+}
 // Make sure CompiledIC_lock in unlocked, since we might update some
 // inline caches. If it is, we just bail-out and try later.
 if (CompiledIC_lock->is_locked() || Patching_lock->is_locked()) return;
 // Check for restart
 assert(CodeCache::find_blob_unsafe(_current) == _current, "Sweeper nmethod cached state invalid");
 if (_current == NULL) {
 _seen        = 0;
 _invocations = NmethodSweepFraction;
-_current     = CodeCache::first();
+_current     = CodeCache::first_nmethod();
 _traversals  += 1;
 if (PrintMethodFlushing) {
 tty->print_cr("### Sweep: stack traversal %d", _traversals);
 }
 Threads::nmethods_do(&mark_activation_closure);
 _rescan = false;
 _locked_seen = 0;
 _not_entrant_seen_on_stack = 0;
 }
-if (PrintMethodFlushing && Verbose) {
-tty->print_cr("### Sweep at %d out of %d. Invocations left: %d", _seen, CodeCache::nof_blobs(), _invocations);
-}
-// We want to visit all nmethods after NmethodSweepFraction invocations.
-// If invocation is 1 we do the rest
-int todo = CodeCache::nof_blobs();
-if (_invocations != 1) {
-todo = (CodeCache::nof_blobs() - _seen) / _invocations;
-_invocations--;
-}
-for(int i = 0; i < todo && _current != NULL; i++) {
-CodeBlob* next = CodeCache::next(_current); // Read next before we potentially delete current
-if (_current->is_nmethod()) {
-process_nmethod((nmethod *)_current);
-}
-_seen++;
-_current = next;
-}
-// Because we could stop on a codeBlob other than an nmethod we skip forward
-// to the next nmethod (if any). codeBlobs other than nmethods can be freed
-// async to us and make _current invalid while we sleep.
-while (_current != NULL && !_current->is_nmethod()) {
-_current = CodeCache::next(_current);
-}
-if (_current == NULL && !_rescan && (_locked_seen || _not_entrant_seen_on_stack)) {
-// we've completed a scan without making progress but there were
-// nmethods we were unable to process either because they were
-// locked or were still on stack.  We don't have to aggresively
-// clean them up so just stop scanning.  We could scan once more
-// but that complicates the control logic and it's unlikely to
-// matter much.
-if (PrintMethodFlushing) {
-tty->print_cr("### Couldn't make progress on some nmethods so stopping sweep");
-}
-}
 if (UseCodeCacheFlushing) {
 if (!CodeCache::needs_flushing()) {
-// In a safepoint, no race with setters
+// scan_stacks() runs during a safepoint, no race with setters
 _advise_to_sweep = 0;
 }
 if (was_full()) {
 // There was some progress so attempt to restart the compiler
 }
 }
 }
 }
+void NMethodSweeper::possibly_sweep() {
+if ((!MethodFlushing) || (!_do_sweep)) return;
+if (_invocations > 0) {
+// Only one thread at a time will sweep
+jint old = Atomic::cmpxchg( 1, &_sweep_started, 0 );
+if (old != 0) {
+return;
+}
+sweep_code_cache();
+}
+_sweep_started = 0;
+}
+void NMethodSweeper::sweep_code_cache() {
+#ifdef ASSERT
+jlong sweep_start;
+if(PrintMethodFlushing) {
+sweep_start = os::javaTimeMillis();
+}
+#endif
+if (PrintMethodFlushing && Verbose) {
+tty->print_cr("### Sweep at %d out of %d. Invocations left: %d", _seen, CodeCache::nof_blobs(), _invocations);
+}
+// We want to visit all nmethods after NmethodSweepFraction invocations.
+// If invocation is 1 we do the rest
+int todo = CodeCache::nof_blobs();
+if (_invocations > 1) {
+todo = (CodeCache::nof_blobs() - _seen) / _invocations;
+}
+// Compilers may check to sweep more often than stack scans happen,
+// don't keep trying once it is all scanned
+_invocations--;
+assert(!SafepointSynchronize::is_at_safepoint(), "should not be in safepoint when we get here");
+assert(!CodeCache_lock->owned_by_self(), "just checking");
+{
+MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
+for(int i = 0; i < todo && _current != NULL; i++) {
+// Since we will give up the CodeCache_lock, always skip ahead to an nmethod.
+// Other blobs can be deleted by other threads
+// Read next before we potentially delete current
+CodeBlob* next = CodeCache::next_nmethod(_current);
+// Now ready to process nmethod and give up CodeCache_lock
+{
+MutexUnlockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
+process_nmethod((nmethod *)_current);
+}
+_seen++;
+_current = next;
+}
+// Skip forward to the next nmethod (if any). Code blobs other than nmethods
+// can be freed async to us and make _current invalid while we sleep.
+_current = CodeCache::next_nmethod(_current);
+}
+if (_current == NULL && !_rescan && (_locked_seen || _not_entrant_seen_on_stack)) {
+// we've completed a scan without making progress but there were
+// nmethods we were unable to process either because they were
+// locked or were still on stack.  We don't have to aggresively
+// clean them up so just stop scanning.  We could scan once more
+// but that complicates the control logic and it's unlikely to
+// matter much.
+if (PrintMethodFlushing) {
+tty->print_cr("### Couldn't make progress on some nmethods so stopping sweep");
+}
+}
+#ifdef ASSERT
+if(PrintMethodFlushing) {
+jlong sweep_end             = os::javaTimeMillis();
+tty->print_cr("### sweeper:      sweep time(%d): " INT64_FORMAT, _invocations, sweep_end - sweep_start);
+}
+#endif
+}
 void NMethodSweeper::process_nmethod(nmethod *nm) {
+assert(!CodeCache_lock->owned_by_self(), "just checking");
 // Skip methods that are currently referenced by the VM
 if (nm->is_locked_by_vm()) {
 // But still remember to clean-up inline caches for alive nmethods
 if (nm->is_alive()) {
 // Clean-up all inline caches that points to zombie/non-reentrant methods
+MutexLocker cl(CompiledIC_lock);
 nm->cleanup_inline_caches();
 } else {
 _locked_seen++;
 }
 return;
 if (nm->is_marked_for_reclamation()) {
 assert(!nm->is_locked_by_vm(), "must not flush locked nmethods");
 if (PrintMethodFlushing && Verbose) {
 tty->print_cr("### Nmethod %3d/" PTR_FORMAT " (marked for reclamation) being flushed", nm->compile_id(), nm);
 }
+MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
 nm->flush();
 } else {
 if (PrintMethodFlushing && Verbose) {
 tty->print_cr("### Nmethod %3d/" PTR_FORMAT " (zombie) being marked for reclamation", nm->compile_id(), nm);
 }
 }
 nm->make_zombie();
 _rescan = true;
 } else {
 // Still alive, clean up its inline caches
+MutexLocker cl(CompiledIC_lock);
 nm->cleanup_inline_caches();
 // we coudn't transition this nmethod so don't immediately
 // request a rescan.  If this method stays on the stack for a
-// long time we don't want to keep rescanning at every safepoint.
+// long time we don't want to keep rescanning the code cache.
 _not_entrant_seen_on_stack++;
 }
 } else if (nm->is_unloaded()) {
 // Unloaded code, just make it a zombie
 if (PrintMethodFlushing && Verbose)
 tty->print_cr("### Nmethod %3d/" PTR_FORMAT " (unloaded) being made zombie", nm->compile_id(), nm);
 if (nm->is_osr_method()) {
 // No inline caches will ever point to osr methods, so we can just remove it
+MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
 nm->flush();
 } else {
 nm->make_zombie();
 _rescan = true;
 }
 nm->make_not_entrant();
 }
 }
 // Clean-up all inline caches that points to zombie/non-reentrant methods
+MutexLocker cl(CompiledIC_lock);
 nm->cleanup_inline_caches();
 }
 }
 // Code cache unloading: when compilers notice the code cache is getting full,
 // they will call a vm op that comes here. This code attempts to speculatively
 // unload the oldest half of the nmethods (based on the compile job id) by
 // saving the old code in a list in the CodeCache. Then
-// execution resumes. If a method so marked is not called by the second
+// execution resumes. If a method so marked is not called by the second sweeper
-// safepoint from the current one, the nmethod will be marked non-entrant and
+// stack traversal after the current one, the nmethod will be marked non-entrant and
 // got rid of by normal sweeping. If the method is called, the methodOop's
 // _code field is restored and the methodOop/nmethod
 // go back to their normal state.
 void NMethodSweeper::handle_full_code_cache(bool is_full) {
 // Only the first one to notice can advise us to start early cleaning
 disconnected, made_not_entrant, CodeCache::nof_blobs(), CodeCache::unallocated_capacity());
 xtty->stamp();
 xtty->end_elem();
 }
-// Shut off compiler. Sweeper will run exiting from this safepoint
+// Shut off compiler. Sweeper will start over with a new stack scan and
-// and turn it back on if it clears enough space
+// traversal cycle and turn it back on if it clears enough space.
 if (was_full()) {
 _last_was_full = os::javaTimeMillis();
 CompileBroker::set_should_compile_new_jobs(CompileBroker::stop_compilation);
 }

changeset 5533	e8d9ff82ec62
parent 4750	71fd601907dc
child 5547	f4b087cbb361