1 /*
   2  * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
   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  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "code/codeCache.hpp"
  27 #include "code/compiledIC.hpp"
  28 #include "code/icBuffer.hpp"
  29 #include "code/nmethod.hpp"
  30 #include "compiler/compileBroker.hpp"
  31 #include "memory/resourceArea.hpp"
  32 #include "oops/method.hpp"
  33 #include "runtime/atomic.hpp"
  34 #include "runtime/compilationPolicy.hpp"
  35 #include "runtime/mutexLocker.hpp"
  36 #include "runtime/os.hpp"
  37 #include "runtime/sweeper.hpp"
  38 #include "runtime/vm_operations.hpp"
  39 #include "trace/tracing.hpp"
  40 #include "utilities/events.hpp"
  41 #include "utilities/xmlstream.hpp"
  42 
  43 #ifdef ASSERT
  44 
  45 #define SWEEP(nm) record_sweep(nm, __LINE__)
  46 // Sweeper logging code
  47 class SweeperRecord {
  48  public:
  49   int traversal;
  50   int invocation;
  51   int compile_id;
  52   long traversal_mark;
  53   int state;
  54   const char* kind;
  55   address vep;
  56   address uep;
  57   int line;
  58 
  59   void print() {
  60       tty->print_cr("traversal = %d invocation = %d compile_id = %d %s uep = " PTR_FORMAT " vep = "
  61                     PTR_FORMAT " state = %d traversal_mark %d line = %d",
  62                     traversal,
  63                     invocation,
  64                     compile_id,
  65                     kind == NULL ? "" : kind,
  66                     uep,
  67                     vep,
  68                     state,
  69                     traversal_mark,
  70                     line);
  71   }
  72 };
  73 
  74 static int _sweep_index = 0;
  75 static SweeperRecord* _records = NULL;
  76 
  77 void NMethodSweeper::report_events(int id, address entry) {
  78   if (_records != NULL) {
  79     for (int i = _sweep_index; i < SweeperLogEntries; i++) {
  80       if (_records[i].uep == entry ||
  81           _records[i].vep == entry ||
  82           _records[i].compile_id == id) {
  83         _records[i].print();
  84       }
  85     }
  86     for (int i = 0; i < _sweep_index; i++) {
  87       if (_records[i].uep == entry ||
  88           _records[i].vep == entry ||
  89           _records[i].compile_id == id) {
  90         _records[i].print();
  91       }
  92     }
  93   }
  94 }
  95 
  96 void NMethodSweeper::report_events() {
  97   if (_records != NULL) {
  98     for (int i = _sweep_index; i < SweeperLogEntries; i++) {
  99       // skip empty records
 100       if (_records[i].vep == NULL) continue;
 101       _records[i].print();
 102     }
 103     for (int i = 0; i < _sweep_index; i++) {
 104       // skip empty records
 105       if (_records[i].vep == NULL) continue;
 106       _records[i].print();
 107     }
 108   }
 109 }
 110 
 111 void NMethodSweeper::record_sweep(nmethod* nm, int line) {
 112   if (_records != NULL) {
 113     _records[_sweep_index].traversal = _traversals;
 114     _records[_sweep_index].traversal_mark = nm->_stack_traversal_mark;
 115     _records[_sweep_index].invocation = _invocations;
 116     _records[_sweep_index].compile_id = nm->compile_id();
 117     _records[_sweep_index].kind = nm->compile_kind();
 118     _records[_sweep_index].state = nm->_state;
 119     _records[_sweep_index].vep = nm->verified_entry_point();
 120     _records[_sweep_index].uep = nm->entry_point();
 121     _records[_sweep_index].line = line;
 122 
 123     _sweep_index = (_sweep_index + 1) % SweeperLogEntries;
 124   }
 125 }
 126 #else
 127 #define SWEEP(nm)
 128 #endif
 129 
 130 
 131 long      NMethodSweeper::_traversals = 0;   // No. of stack traversals performed
 132 nmethod*  NMethodSweeper::_current = NULL;   // Current nmethod
 133 int       NMethodSweeper::_seen = 0 ;        // No. of nmethods we have currently processed in current pass of CodeCache
 134 int       NMethodSweeper::_flushed_count = 0;   // Nof. nmethods flushed in current sweep
 135 int       NMethodSweeper::_zombified_count = 0; // Nof. nmethods made zombie in current sweep
 136 int       NMethodSweeper::_marked_count = 0;    // Nof. nmethods marked for reclaim in current sweep
 137 
 138 volatile int NMethodSweeper::_invocations = 0;   // No. of invocations left until we are completed with this pass
 139 volatile int NMethodSweeper::_sweep_started = 0; // Whether a sweep is in progress.
 140 
 141 jint      NMethodSweeper::_locked_seen = 0;
 142 jint      NMethodSweeper::_not_entrant_seen_on_stack = 0;
 143 bool      NMethodSweeper::_resweep = false;
 144 jint      NMethodSweeper::_flush_token = 0;
 145 jlong     NMethodSweeper::_last_full_flush_time = 0;
 146 long      NMethodSweeper::_last_flush_traversal_id = 0;
 147 
 148 int       NMethodSweeper::_number_of_flushes = 0; // Total of full traversals caused by full cache
 149 int       NMethodSweeper::_total_nof_methods_reclaimed = 0;
 150 jlong     NMethodSweeper::_total_time_sweeping = 0;
 151 jlong     NMethodSweeper::_total_time_this_sweep = 0;
 152 jlong     NMethodSweeper::_peak_sweep_time = 0;
 153 jlong     NMethodSweeper::_peak_sweep_fraction_time = 0;
 154 jlong     NMethodSweeper::_total_disconnect_time = 0;
 155 jlong     NMethodSweeper::_peak_disconnect_time = 0;
 156 
 157 class MarkActivationClosure: public CodeBlobClosure {
 158 public:
 159   virtual void do_code_blob(CodeBlob* cb) {
 160     if (cb->is_nmethod()) {
 161       nmethod* nm = (nmethod*)cb;
 162       nm->set_hotness_counter(NMethodSweeper::hc_reset_value);
 163       // If we see an activation belonging to a non_entrant nmethod, we mark it.
 164       if (nm->is_not_entrant()) {
 165         nm->mark_as_seen_on_stack();
 166       }
 167     }
 168   }
 169 };
 170 static MarkActivationClosure mark_activation_closure;
 171 
 172 bool NMethodSweeper::sweep_in_progress() {
 173   return (_current != NULL);
 174 }
 175 
 176 void NMethodSweeper::scan_stacks() {
 177   assert(SafepointSynchronize::is_at_safepoint(), "must be executed at a safepoint");
 178   if (!MethodFlushing) return;
 179 
 180   // No need to synchronize access, since this is always executed at a
 181   // safepoint.
 182 
 183   // Make sure CompiledIC_lock in unlocked, since we might update some
 184   // inline caches. If it is, we just bail-out and try later.
 185   if (CompiledIC_lock->is_locked() || Patching_lock->is_locked()) return;
 186 
 187   // Check for restart
 188   assert(CodeCache::find_blob_unsafe(_current) == _current, "Sweeper nmethod cached state invalid");
 189   if (!sweep_in_progress() && _resweep) {
 190     _seen        = 0;
 191     _invocations = NmethodSweepFraction;
 192     _current     = CodeCache::first_nmethod();
 193     _traversals  += 1;
 194     _total_time_this_sweep = 0;
 195 
 196     if (PrintMethodFlushing) {
 197       tty->print_cr("### Sweep: stack traversal %d", _traversals);
 198     }
 199     Threads::nmethods_do(&mark_activation_closure);
 200 
 201     // reset the flags since we started a scan from the beginning.
 202     _resweep = false;
 203     _locked_seen = 0;
 204     _not_entrant_seen_on_stack = 0;
 205   }
 206 
 207   if (UseCodeCacheFlushing) {
 208     // only allow new flushes after the interval is complete.
 209     jlong now           = os::javaTimeMillis();
 210     jlong max_interval  = (jlong)MinCodeCacheFlushingInterval * (jlong)1000;
 211     jlong curr_interval = now - _last_full_flush_time;
 212     if (curr_interval > max_interval) {
 213       _flush_token = 0;
 214     }
 215 
 216     if (!CodeCache::needs_flushing() && !CompileBroker::should_compile_new_jobs()) {
 217       CompileBroker::set_should_compile_new_jobs(CompileBroker::run_compilation);
 218       log_sweep("restart_compiler");
 219     }
 220   }
 221 }
 222 
 223 void NMethodSweeper::possibly_sweep() {
 224   assert(JavaThread::current()->thread_state() == _thread_in_vm, "must run in vm mode");
 225   if (!MethodFlushing || !sweep_in_progress()) return;
 226 
 227   if (_invocations > 0) {
 228     // Only one thread at a time will sweep
 229     jint old = Atomic::cmpxchg( 1, &_sweep_started, 0 );
 230     if (old != 0) {
 231       return;
 232     }
 233 #ifdef ASSERT
 234     if (LogSweeper && _records == NULL) {
 235       // Create the ring buffer for the logging code
 236       _records = NEW_C_HEAP_ARRAY(SweeperRecord, SweeperLogEntries, mtGC);
 237       memset(_records, 0, sizeof(SweeperRecord) * SweeperLogEntries);
 238     }
 239 #endif
 240     if (_invocations > 0) {
 241       sweep_code_cache();
 242       _invocations--;
 243     }
 244     _sweep_started = 0;
 245   }
 246 }
 247 
 248 void NMethodSweeper::sweep_code_cache() {
 249 
 250   jlong sweep_start_counter = os::elapsed_counter();
 251 
 252   _flushed_count   = 0;
 253   _zombified_count = 0;
 254   _marked_count    = 0;
 255 
 256   if (PrintMethodFlushing && Verbose) {
 257     tty->print_cr("### Sweep at %d out of %d. Invocations left: %d", _seen, CodeCache::nof_nmethods(), _invocations);
 258   }
 259 
 260   if (!CompileBroker::should_compile_new_jobs()) {
 261     // If we have turned off compilations we might as well do full sweeps
 262     // in order to reach the clean state faster. Otherwise the sleeping compiler
 263     // threads will slow down sweeping. After a few iterations the cache
 264     // will be clean and sweeping stops (_resweep will not be set)
 265     _invocations = 1;
 266   }
 267 
 268   // We want to visit all nmethods after NmethodSweepFraction
 269   // invocations so divide the remaining number of nmethods by the
 270   // remaining number of invocations.  This is only an estimate since
 271   // the number of nmethods changes during the sweep so the final
 272   // stage must iterate until it there are no more nmethods.
 273   int todo = (CodeCache::nof_nmethods() - _seen) / _invocations;
 274 
 275   assert(!SafepointSynchronize::is_at_safepoint(), "should not be in safepoint when we get here");
 276   assert(!CodeCache_lock->owned_by_self(), "just checking");
 277 
 278   {
 279     MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
 280 
 281     // The last invocation iterates until there are no more nmethods
 282     for (int i = 0; (i < todo || _invocations == 1) && _current != NULL; i++) {
 283       if (SafepointSynchronize::is_synchronizing()) { // Safepoint request
 284         if (PrintMethodFlushing && Verbose) {
 285           tty->print_cr("### Sweep at %d out of %d, invocation: %d, yielding to safepoint", _seen, CodeCache::nof_nmethods(), _invocations);
 286         }
 287         MutexUnlockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
 288 
 289         assert(Thread::current()->is_Java_thread(), "should be java thread");
 290         JavaThread* thread = (JavaThread*)Thread::current();
 291         ThreadBlockInVM tbivm(thread);
 292         thread->java_suspend_self();
 293       }
 294       // Since we will give up the CodeCache_lock, always skip ahead
 295       // to the next nmethod.  Other blobs can be deleted by other
 296       // threads but nmethods are only reclaimed by the sweeper.
 297       nmethod* next = CodeCache::next_nmethod(_current);
 298 
 299       // Now ready to process nmethod and give up CodeCache_lock
 300       {
 301         MutexUnlockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
 302         process_nmethod(_current);
 303       }
 304       _seen++;
 305       _current = next;
 306     }
 307   }
 308 
 309   assert(_invocations > 1 || _current == NULL, "must have scanned the whole cache");
 310 
 311   if (!sweep_in_progress() && !_resweep && (_locked_seen || _not_entrant_seen_on_stack)) {
 312     // we've completed a scan without making progress but there were
 313     // nmethods we were unable to process either because they were
 314     // locked or were still on stack.  We don't have to aggressively
 315     // clean them up so just stop scanning. We could scan once more
 316     // but that complicates the control logic and it's unlikely to
 317     // matter much.
 318     if (PrintMethodFlushing) {
 319       tty->print_cr("### Couldn't make progress on some nmethods so stopping sweep");
 320     }
 321   }
 322 
 323   jlong sweep_end_counter = os::elapsed_counter();
 324   jlong sweep_time = sweep_end_counter - sweep_start_counter;
 325   _total_time_sweeping  += sweep_time;
 326   _total_time_this_sweep += sweep_time;
 327   _peak_sweep_fraction_time = MAX2(sweep_time, _peak_sweep_fraction_time);
 328   _total_nof_methods_reclaimed += _flushed_count;
 329 
 330   EventSweepCodeCache event(UNTIMED);
 331   if (event.should_commit()) {
 332     event.set_starttime(sweep_start_counter);
 333     event.set_endtime(sweep_end_counter);
 334     event.set_sweepIndex(_traversals);
 335     event.set_sweepFractionIndex(NmethodSweepFraction - _invocations + 1);
 336     event.set_sweptCount(todo);
 337     event.set_flushedCount(_flushed_count);
 338     event.set_markedCount(_marked_count);
 339     event.set_zombifiedCount(_zombified_count);
 340     event.commit();
 341   }
 342 
 343 #ifdef ASSERT
 344   if(PrintMethodFlushing) {
 345     tty->print_cr("### sweeper:      sweep time(%d): " INT64_FORMAT, _invocations, (jlong)sweep_time);
 346   }
 347 #endif
 348 
 349   if (_invocations == 1) {
 350     _peak_sweep_time = MAX2(_peak_sweep_time, _total_time_this_sweep);
 351     log_sweep("finished");
 352   }
 353 
 354   // Sweeper is the only case where memory is released,
 355   // check here if it is time to restart the compiler.
 356   if (UseCodeCacheFlushing && !CompileBroker::should_compile_new_jobs() && !CodeCache::needs_flushing()) {
 357     CompileBroker::set_should_compile_new_jobs(CompileBroker::run_compilation);
 358     log_sweep("restart_compiler");
 359   }
 360 }
 361 
 362 class NMethodMarker: public StackObj {
 363  private:
 364   CompilerThread* _thread;
 365  public:
 366   NMethodMarker(nmethod* nm) {
 367     _thread = CompilerThread::current();
 368     if (!nm->is_zombie() && !nm->is_unloaded()) {
 369       // Only expose live nmethods for scanning
 370       _thread->set_scanned_nmethod(nm);
 371     }
 372   }
 373   ~NMethodMarker() {
 374     _thread->set_scanned_nmethod(NULL);
 375   }
 376 };
 377 
 378 void NMethodSweeper::release_nmethod(nmethod *nm) {
 379   // Clean up any CompiledICHolders
 380   {
 381     ResourceMark rm;
 382     MutexLocker ml_patch(CompiledIC_lock);
 383     RelocIterator iter(nm);
 384     while (iter.next()) {
 385       if (iter.type() == relocInfo::virtual_call_type) {
 386         CompiledIC::cleanup_call_site(iter.virtual_call_reloc());
 387       }
 388     }
 389   }
 390 
 391   MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
 392   nm->flush();
 393 }
 394 
 395 void NMethodSweeper::process_nmethod(nmethod *nm) {
 396   assert(!CodeCache_lock->owned_by_self(), "just checking");
 397   // Make sure this nmethod doesn't get unloaded during the scan,
 398   // since the locks acquired might below the safepoint.
 399   NMethodMarker nmm(nm);
 400   nm->dec_hotness_counter(NMethodSweeper::hc_dec_value);
 401 
 402   SWEEP(nm);
 403 
 404   // Skip methods that are currently referenced by the VM
 405   if (nm->is_locked_by_vm()) {
 406     // But still remember to clean-up inline caches for alive nmethods
 407     if (nm->is_alive()) {
 408       // Clean-up all inline caches that point to zombie/non-reentrant methods
 409       MutexLocker cl(CompiledIC_lock);
 410       nm->cleanup_inline_caches();
 411       SWEEP(nm);
 412     } else {
 413       _locked_seen++;
 414       SWEEP(nm);
 415     }
 416     return;
 417   }
 418 
 419   if (nm->is_zombie()) {
 420     // If it is the first time we see nmethod then we mark it. Otherwise,
 421     // we reclaim it. When we have seen a zombie method twice, we know that
 422     // there are no inline caches that refer to it.
 423     if (nm->is_marked_for_reclamation()) {
 424       assert(!nm->is_locked_by_vm(), "must not flush locked nmethods");
 425       if (PrintMethodFlushing && Verbose) {
 426         tty->print_cr("### Nmethod %3d/" PTR_FORMAT " (marked for reclamation) being flushed", nm->compile_id(), nm);
 427       }
 428       release_nmethod(nm);
 429       _flushed_count++;
 430     } else {
 431       if (PrintMethodFlushing && Verbose) {
 432         tty->print_cr("### Nmethod %3d/" PTR_FORMAT " (zombie) being marked for reclamation", nm->compile_id(), nm);
 433       }
 434       nm->mark_for_reclamation();
 435       _resweep = true;
 436       _marked_count++;
 437       SWEEP(nm);
 438     }
 439   } else if (nm->is_not_entrant()) {
 440     // If there are no current activations of this method on the
 441     // stack we can safely convert it to a zombie method
 442     if (nm->can_not_entrant_be_converted()) {
 443       if (PrintMethodFlushing && Verbose) {
 444         tty->print_cr("### Nmethod %3d/" PTR_FORMAT " (not entrant) being made zombie", nm->compile_id(), nm);
 445       }
 446       nm->make_zombie();
 447       _resweep = true;
 448       _zombified_count++;
 449       SWEEP(nm);
 450     } else {
 451       // Still alive, clean up its inline caches
 452       MutexLocker cl(CompiledIC_lock);
 453       nm->cleanup_inline_caches();
 454       // we coudn't transition this nmethod so don't immediately
 455       // request a rescan.  If this method stays on the stack for a
 456       // long time we don't want to keep rescanning the code cache.
 457       _not_entrant_seen_on_stack++;
 458       SWEEP(nm);
 459     }
 460   } else if (nm->is_unloaded()) {
 461     // Unloaded code, just make it a zombie
 462     if (PrintMethodFlushing && Verbose)
 463       tty->print_cr("### Nmethod %3d/" PTR_FORMAT " (unloaded) being made zombie", nm->compile_id(), nm);
 464 
 465     if (nm->is_osr_method()) {
 466       SWEEP(nm);
 467       // No inline caches will ever point to osr methods, so we can just remove it
 468       release_nmethod(nm);
 469       _flushed_count++;
 470     } else {
 471       nm->make_zombie();
 472       _resweep = true;
 473       _zombified_count++;
 474       SWEEP(nm);
 475     }
 476   } else {
 477     assert(nm->is_alive(), "should be alive");
 478     if (UseCodeCacheFlushing) {
 479       if (!nm->is_locked_by_vm() && !nm->is_osr_method()) {
 480         if (!nm->is_speculatively_disconnected()) {
 481           // This method is cold and the code cache fills up => get rid of it.
 482           double threshold = -100 + (CodeCache::reverse_free_ratio() * NmethodSweepActivity);
 483           if (nm->get_hotness_counter() < threshold) {
 484             nm->make_not_entrant();
 485           }
 486         } else if (nm->is_speculatively_disconnected() && (_traversals > _last_flush_traversal_id + 2)) {
 487           // This method has not been called since the forced cleanup happened
 488           nm->make_not_entrant();
 489         }
 490       }
 491     }
 492     // Clean-up all inline caches that points to zombie/non-reentrant methods
 493     MutexLocker cl(CompiledIC_lock);
 494     nm->cleanup_inline_caches();
 495     SWEEP(nm);
 496   }
 497 }
 498 
 499 // Code cache unloading: when compilers notice the code cache is getting full,
 500 // they will call a vm op that comes here. This code attempts to speculatively
 501 // unload the coldest part (the part is defined by CodeCacheFlushingFraction) of
 502 // the nmethods by saving the cold code in a list in the CodeCache. Then
 503 // execution resumes. If a method so marked is not called by the second sweeper
 504 // stack traversal after the current one, the nmethod will be marked non-entrant and
 505 // got rid of by normal sweeping. If the method is called, the Method*'s
 506 // _code field is restored and the Method*/nmethod
 507 // go back to their normal state.
 508 void NMethodSweeper::handle_full_code_cache(bool is_full) {
 509 
 510   if (is_full) {
 511     // Since code cache is full, immediately stop new compiles
 512     if (CompileBroker::set_should_compile_new_jobs(CompileBroker::stop_compilation)) {
 513       log_sweep("disable_compiler");
 514     }
 515   }
 516 
 517   // Make sure only one thread can flush
 518   // The token is reset after CodeCacheMinimumFlushInterval in scan stacks,
 519   // no need to check the timeout here.
 520   jint old = Atomic::cmpxchg( 1, &_flush_token, 0 );
 521   if (old != 0) {
 522     return;
 523   }
 524 
 525   VM_HandleFullCodeCache op(is_full);
 526   VMThread::execute(&op);
 527 
 528   // resweep again as soon as possible
 529   _resweep = true;
 530 }
 531 
 532 int NMethodSweeper::sort_nmentod_by_hotness(nmethod** nm1, nmethod** nm2) {
 533   return ((*(nm1))->get_hotness_counter() > (*nm2)->get_hotness_counter());
 534 }
 535 
 536 void NMethodSweeper::speculative_disconnect_nmethods(bool is_full) {
 537   // If there was a race in detecting full code cache, only run
 538   // one vm op for it or keep the compiler shut off
 539   jlong disconnect_start_counter = os::elapsed_counter();
 540 
 541   jint disconnected = 0;
 542   jint made_not_entrant  = 0;
 543   jint nmethod_count = 0;
 544 
 545   log_sweep("start_cleaning");
 546 
 547   {
 548     ResourceMark rm;
 549     GrowableArray<nmethod*>* live_methods= new GrowableArray<nmethod*>();
 550     nmethod* nm = CodeCache::next_nmethod(CodeCache::first());
 551 
 552     size_t methods_to_flush = CodeCache::nof_nmethods() / CodeCacheFlushingFraction;
 553     size_t methods_will_be_flushed = 0;
 554     size_t nmethods = 0;
 555 
 556     // See how many methods are 'in flight' of being flushed
 557     while ((nm != NULL) && (methods_will_be_flushed < methods_to_flush)) {
 558       // OSR methods cannot be flushed like this. Also, don't flush native methods
 559       // since they are part of the JDK in most cases
 560       if (!nm->is_osr_method() && !nm->is_locked_by_vm() && !nm->is_native_method() && nm->is_alive()) {
 561         if ((nm->is_in_use()) && (nm->method()->code() == nm)) {
 562           live_methods->append(nm);
 563         } else if (nm->is_speculatively_disconnected()) {
 564           // This method was previously considered for preemptive unloading and was not called since then
 565           CompilationPolicy::policy()->delay_compilation(nm->method());
 566           nm->make_not_entrant();
 567           made_not_entrant++;
 568           methods_will_be_flushed++;
 569         } else {
 570           methods_will_be_flushed++;
 571         }
 572       }
 573       nm = CodeCache::next_nmethod(nm);
 574     }
 575 
 576     // Speculatively disconnect methods until we reach 'memory_to_flush'
 577     if (methods_will_be_flushed < methods_to_flush) {
 578       live_methods->sort(sort_nmentod_by_hotness);
 579       //Iterate over sorted array and speculatively disconnect these nmethods
 580       for (int i = 0; i < live_methods->length(); i++) {
 581         nm = live_methods->at(i);
 582         if (methods_will_be_flushed < methods_to_flush) {
 583           // Method was not previously disconnected
 584           if ((nm->method()->code() == nm)) {
 585             CodeCache::speculatively_disconnect(nm);
 586             disconnected++;
 587             methods_will_be_flushed++;
 588           }
 589         } else {
 590           // The requested number of nmethods is scheduled for flushing
 591           break;
 592         }
 593       }
 594     }
 595   }
 596 
 597   log_sweep("stop_cleaning",
 598                        "disconnected='" UINT32_FORMAT "' made_not_entrant='" UINT32_FORMAT "'",
 599                        disconnected, made_not_entrant);
 600 
 601   // Shut off compiler. Sweeper will start over with a new stack scan and
 602   // traversal cycle and turn it back on if it clears enough space.
 603   if (is_full) {
 604     _last_full_flush_time = os::javaTimeMillis();
 605   }
 606 
 607   jlong disconnect_end_counter = os::elapsed_counter();
 608   jlong disconnect_time = disconnect_end_counter - disconnect_start_counter;
 609   _total_disconnect_time += disconnect_time;
 610   _peak_disconnect_time = MAX2(disconnect_time, _peak_disconnect_time);
 611 
 612   EventCleanCodeCache event(UNTIMED);
 613   if (event.should_commit()) {
 614     event.set_starttime(disconnect_start_counter);
 615     event.set_endtime(disconnect_end_counter);
 616     event.set_disconnectedCount(disconnected);
 617     event.set_madeNonEntrantCount(made_not_entrant);
 618     event.commit();
 619   }
 620   _number_of_flushes++;
 621 
 622   // After two more traversals the sweeper will get rid of unrestored nmethods
 623   _last_flush_traversal_id = _traversals;
 624   _resweep = true;
 625 #ifdef ASSERT
 626 
 627   if(PrintMethodFlushing && Verbose) {
 628     tty->print_cr("### sweeper: unload time: " INT64_FORMAT, (jlong)disconnect_time);
 629   }
 630 #endif
 631 }
 632 
 633 
 634 // Print out some state information about the current sweep and the
 635 // state of the code cache if it's requested.
 636 void NMethodSweeper::log_sweep(const char* msg, const char* format, ...) {
 637   if (PrintMethodFlushing) {
 638     stringStream s;
 639     // Dump code cache state into a buffer before locking the tty,
 640     // because log_state() will use locks causing lock conflicts.
 641     CodeCache::log_state(&s);
 642 
 643     ttyLocker ttyl;
 644     tty->print("### sweeper: %s ", msg);
 645     if (format != NULL) {
 646       va_list ap;
 647       va_start(ap, format);
 648       tty->vprint(format, ap);
 649       va_end(ap);
 650     }
 651     tty->print_cr(s.as_string());
 652   }
 653 
 654   if (LogCompilation && (xtty != NULL)) {
 655     stringStream s;
 656     // Dump code cache state into a buffer before locking the tty,
 657     // because log_state() will use locks causing lock conflicts.
 658     CodeCache::log_state(&s);
 659 
 660     ttyLocker ttyl;
 661     xtty->begin_elem("sweeper state='%s' traversals='" INTX_FORMAT "' ", msg, (intx)traversal_count());
 662     if (format != NULL) {
 663       va_list ap;
 664       va_start(ap, format);
 665       xtty->vprint(format, ap);
 666       va_end(ap);
 667     }
 668     xtty->print(s.as_string());
 669     xtty->stamp();
 670     xtty->end_elem();
 671   }
 672 }