src/share/vm/runtime/sweeper.cpp

Print this page
rev 4773 : 8005849: JEP 167: Event-Based JVM Tracing
Reviewed-by: acorn, coleenp, sla
Contributed-by: Karen Kinnear <karen.kinnear@oracle.com>, Bengt Rutisson <bengt.rutisson@oracle.com>, Calvin Cheung <calvin.cheung@oracle.com>, Erik Gahlin <erik.gahlin@oracle.com>, Erik Helin <erik.helin@oracle.com>, Jesper Wilhelmsson <jesper.wilhelmsson@oracle.com>, Keith McGuigan <keith.mcguigan@oracle.com>, Mattias Tobiasson <mattias.tobiasson@oracle.com>, Markus Gronlund <markus.gronlund@oracle.com>, Mikael Auno <mikael.auno@oracle.com>, Nils Eliasson <nils.eliasson@oracle.com>, Nils Loodin <nils.loodin@oracle.com>, Rickard Backman <rickard.backman@oracle.com>, Staffan Larsen <staffan.larsen@oracle.com>, Stefan Karlsson <stefan.karlsson@oracle.com>, Yekaterina Kantserova <yekaterina.kantserova@oracle.com>
   1 /*
   2  * Copyright (c) 1997, 2012, 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 "utilities/events.hpp"
  40 #include "utilities/xmlstream.hpp"
  41 
  42 #ifdef ASSERT
  43 
  44 #define SWEEP(nm) record_sweep(nm, __LINE__)
  45 // Sweeper logging code
  46 class SweeperRecord {
  47  public:
  48   int traversal;
  49   int invocation;
  50   int compile_id;
  51   long traversal_mark;
  52   int state;
  53   const char* kind;
  54   address vep;
  55   address uep;
  56   int line;
  57 
  58   void print() {


 113     _records[_sweep_index].traversal_mark = nm->_stack_traversal_mark;
 114     _records[_sweep_index].invocation = _invocations;
 115     _records[_sweep_index].compile_id = nm->compile_id();
 116     _records[_sweep_index].kind = nm->compile_kind();
 117     _records[_sweep_index].state = nm->_state;
 118     _records[_sweep_index].vep = nm->verified_entry_point();
 119     _records[_sweep_index].uep = nm->entry_point();
 120     _records[_sweep_index].line = line;
 121 
 122     _sweep_index = (_sweep_index + 1) % SweeperLogEntries;
 123   }
 124 }
 125 #else
 126 #define SWEEP(nm)
 127 #endif
 128 
 129 
 130 long      NMethodSweeper::_traversals = 0;   // No. of stack traversals performed
 131 nmethod*  NMethodSweeper::_current = NULL;   // Current nmethod
 132 int       NMethodSweeper::_seen = 0 ;        // No. of nmethods we have currently processed in current pass of CodeCache



 133 
 134 volatile int NMethodSweeper::_invocations = 0;   // No. of invocations left until we are completed with this pass
 135 volatile int NMethodSweeper::_sweep_started = 0; // Whether a sweep is in progress.
 136 
 137 jint      NMethodSweeper::_locked_seen = 0;
 138 jint      NMethodSweeper::_not_entrant_seen_on_stack = 0;
 139 bool      NMethodSweeper::_resweep = false;
 140 jint      NMethodSweeper::_flush_token = 0;
 141 jlong     NMethodSweeper::_last_full_flush_time = 0;
 142 int       NMethodSweeper::_highest_marked = 0;
 143 int       NMethodSweeper::_dead_compile_ids = 0;
 144 long      NMethodSweeper::_last_flush_traversal_id = 0;
 145 









 146 class MarkActivationClosure: public CodeBlobClosure {
 147 public:
 148   virtual void do_code_blob(CodeBlob* cb) {
 149     // If we see an activation belonging to a non_entrant nmethod, we mark it.
 150     if (cb->is_nmethod() && ((nmethod*)cb)->is_not_entrant()) {
 151       ((nmethod*)cb)->mark_as_seen_on_stack();
 152     }
 153   }
 154 };
 155 static MarkActivationClosure mark_activation_closure;
 156 
 157 bool NMethodSweeper::sweep_in_progress() {
 158   return (_current != NULL);
 159 }
 160 
 161 void NMethodSweeper::scan_stacks() {
 162   assert(SafepointSynchronize::is_at_safepoint(), "must be executed at a safepoint");
 163   if (!MethodFlushing) return;
 164 
 165   // No need to synchronize access, since this is always executed at a
 166   // safepoint.
 167 
 168   // Make sure CompiledIC_lock in unlocked, since we might update some
 169   // inline caches. If it is, we just bail-out and try later.
 170   if (CompiledIC_lock->is_locked() || Patching_lock->is_locked()) return;
 171 
 172   // Check for restart
 173   assert(CodeCache::find_blob_unsafe(_current) == _current, "Sweeper nmethod cached state invalid");
 174   if (!sweep_in_progress() && _resweep) {
 175     _seen        = 0;
 176     _invocations = NmethodSweepFraction;
 177     _current     = CodeCache::first_nmethod();
 178     _traversals  += 1;


 179     if (PrintMethodFlushing) {
 180       tty->print_cr("### Sweep: stack traversal %d", _traversals);
 181     }
 182     Threads::nmethods_do(&mark_activation_closure);
 183 
 184     // reset the flags since we started a scan from the beginning.
 185     _resweep = false;
 186     _locked_seen = 0;
 187     _not_entrant_seen_on_stack = 0;
 188   }
 189 
 190   if (UseCodeCacheFlushing) {
 191     // only allow new flushes after the interval is complete.
 192     jlong now           = os::javaTimeMillis();
 193     jlong max_interval  = (jlong)MinCodeCacheFlushingInterval * (jlong)1000;
 194     jlong curr_interval = now - _last_full_flush_time;
 195     if (curr_interval > max_interval) {
 196       _flush_token = 0;
 197     }
 198 


 212     jint old = Atomic::cmpxchg( 1, &_sweep_started, 0 );
 213     if (old != 0) {
 214       return;
 215     }
 216 #ifdef ASSERT
 217     if (LogSweeper && _records == NULL) {
 218       // Create the ring buffer for the logging code
 219       _records = NEW_C_HEAP_ARRAY(SweeperRecord, SweeperLogEntries, mtGC);
 220       memset(_records, 0, sizeof(SweeperRecord) * SweeperLogEntries);
 221     }
 222 #endif
 223     if (_invocations > 0) {
 224       sweep_code_cache();
 225       _invocations--;
 226     }
 227     _sweep_started = 0;
 228   }
 229 }
 230 
 231 void NMethodSweeper::sweep_code_cache() {
 232 #ifdef ASSERT
 233   jlong sweep_start;
 234   if (PrintMethodFlushing) {
 235     sweep_start = os::javaTimeMillis();
 236   }
 237 #endif

 238   if (PrintMethodFlushing && Verbose) {
 239     tty->print_cr("### Sweep at %d out of %d. Invocations left: %d", _seen, CodeCache::nof_nmethods(), _invocations);
 240   }
 241 
 242   if (!CompileBroker::should_compile_new_jobs()) {
 243     // If we have turned off compilations we might as well do full sweeps
 244     // in order to reach the clean state faster. Otherwise the sleeping compiler
 245     // threads will slow down sweeping. After a few iterations the cache
 246     // will be clean and sweeping stops (_resweep will not be set)
 247     _invocations = 1;
 248   }
 249 
 250   // We want to visit all nmethods after NmethodSweepFraction
 251   // invocations so divide the remaining number of nmethods by the
 252   // remaining number of invocations.  This is only an estimate since
 253   // the number of nmethods changes during the sweep so the final
 254   // stage must iterate until it there are no more nmethods.
 255   int todo = (CodeCache::nof_nmethods() - _seen) / _invocations;
 256 
 257   assert(!SafepointSynchronize::is_at_safepoint(), "should not be in safepoint when we get here");


 285       }
 286       _seen++;
 287       _current = next;
 288     }
 289   }
 290 
 291   assert(_invocations > 1 || _current == NULL, "must have scanned the whole cache");
 292 
 293   if (!sweep_in_progress() && !_resweep && (_locked_seen || _not_entrant_seen_on_stack)) {
 294     // we've completed a scan without making progress but there were
 295     // nmethods we were unable to process either because they were
 296     // locked or were still on stack.  We don't have to aggresively
 297     // clean them up so just stop scanning.  We could scan once more
 298     // but that complicates the control logic and it's unlikely to
 299     // matter much.
 300     if (PrintMethodFlushing) {
 301       tty->print_cr("### Couldn't make progress on some nmethods so stopping sweep");
 302     }
 303   }
 304 




















 305 #ifdef ASSERT
 306   if(PrintMethodFlushing) {
 307     jlong sweep_end             = os::javaTimeMillis();
 308     tty->print_cr("### sweeper:      sweep time(%d): " INT64_FORMAT, _invocations, sweep_end - sweep_start);
 309   }
 310 #endif
 311 
 312   if (_invocations == 1) {

 313     log_sweep("finished");
 314   }
 315 
 316   // Sweeper is the only case where memory is released,
 317   // check here if it is time to restart the compiler.
 318   if (UseCodeCacheFlushing && !CompileBroker::should_compile_new_jobs() && !CodeCache::needs_flushing()) {
 319     CompileBroker::set_should_compile_new_jobs(CompileBroker::run_compilation);
 320     log_sweep("restart_compiler");
 321   }
 322 }
 323 
 324 class NMethodMarker: public StackObj {
 325  private:
 326   CompilerThread* _thread;
 327  public:
 328   NMethodMarker(nmethod* nm) {
 329     _thread = CompilerThread::current();
 330     if (!nm->is_zombie() && !nm->is_unloaded()) {
 331       // Only expose live nmethods for scanning
 332     _thread->set_scanned_nmethod(nm);


 371       MutexLocker cl(CompiledIC_lock);
 372       nm->cleanup_inline_caches();
 373       SWEEP(nm);
 374     } else {
 375       _locked_seen++;
 376       SWEEP(nm);
 377     }
 378     return;
 379   }
 380 
 381   if (nm->is_zombie()) {
 382     // If it is first time, we see nmethod then we mark it. Otherwise,
 383     // we reclame it. When we have seen a zombie method twice, we know that
 384     // there are no inline caches that refer to it.
 385     if (nm->is_marked_for_reclamation()) {
 386       assert(!nm->is_locked_by_vm(), "must not flush locked nmethods");
 387       if (PrintMethodFlushing && Verbose) {
 388         tty->print_cr("### Nmethod %3d/" PTR_FORMAT " (marked for reclamation) being flushed", nm->compile_id(), nm);
 389       }
 390       release_nmethod(nm);

 391     } else {
 392       if (PrintMethodFlushing && Verbose) {
 393         tty->print_cr("### Nmethod %3d/" PTR_FORMAT " (zombie) being marked for reclamation", nm->compile_id(), nm);
 394       }
 395       nm->mark_for_reclamation();
 396       _resweep = true;

 397       SWEEP(nm);
 398     }
 399   } else if (nm->is_not_entrant()) {
 400     // If there is no current activations of this method on the
 401     // stack we can safely convert it to a zombie method
 402     if (nm->can_not_entrant_be_converted()) {
 403       if (PrintMethodFlushing && Verbose) {
 404         tty->print_cr("### Nmethod %3d/" PTR_FORMAT " (not entrant) being made zombie", nm->compile_id(), nm);
 405       }
 406       nm->make_zombie();
 407       _resweep = true;

 408       SWEEP(nm);
 409     } else {
 410       // Still alive, clean up its inline caches
 411       MutexLocker cl(CompiledIC_lock);
 412       nm->cleanup_inline_caches();
 413       // we coudn't transition this nmethod so don't immediately
 414       // request a rescan.  If this method stays on the stack for a
 415       // long time we don't want to keep rescanning the code cache.
 416       _not_entrant_seen_on_stack++;
 417       SWEEP(nm);
 418     }
 419   } else if (nm->is_unloaded()) {
 420     // Unloaded code, just make it a zombie
 421     if (PrintMethodFlushing && Verbose)
 422       tty->print_cr("### Nmethod %3d/" PTR_FORMAT " (unloaded) being made zombie", nm->compile_id(), nm);

 423     if (nm->is_osr_method()) {
 424       SWEEP(nm);
 425       // No inline caches will ever point to osr methods, so we can just remove it
 426       release_nmethod(nm);

 427     } else {
 428       nm->make_zombie();
 429       _resweep = true;

 430       SWEEP(nm);
 431     }
 432   } else {
 433     assert(nm->is_alive(), "should be alive");
 434 
 435     if (UseCodeCacheFlushing) {
 436       if (nm->is_speculatively_disconnected() && !nm->is_locked_by_vm() && !nm->is_osr_method() &&
 437           (_traversals > _last_flush_traversal_id + 2) && (nm->compile_id() < _highest_marked)) {
 438         // This method has not been called since the forced cleanup happened
 439         nm->make_not_entrant();
 440       }
 441     }
 442 
 443     // Clean-up all inline caches that points to zombie/non-reentrant methods
 444     MutexLocker cl(CompiledIC_lock);
 445     nm->cleanup_inline_caches();
 446     SWEEP(nm);
 447   }
 448 }
 449 


 467 
 468   // Make sure only one thread can flush
 469   // The token is reset after CodeCacheMinimumFlushInterval in scan stacks,
 470   // no need to check the timeout here.
 471   jint old = Atomic::cmpxchg( 1, &_flush_token, 0 );
 472   if (old != 0) {
 473     return;
 474   }
 475 
 476   VM_HandleFullCodeCache op(is_full);
 477   VMThread::execute(&op);
 478 
 479   // resweep again as soon as possible
 480   _resweep = true;
 481 }
 482 
 483 void NMethodSweeper::speculative_disconnect_nmethods(bool is_full) {
 484   // If there was a race in detecting full code cache, only run
 485   // one vm op for it or keep the compiler shut off
 486 
 487   debug_only(jlong start = os::javaTimeMillis();)
 488 
 489   // Traverse the code cache trying to dump the oldest nmethods
 490   int curr_max_comp_id = CompileBroker::get_compilation_id();
 491   int flush_target = ((curr_max_comp_id - _dead_compile_ids) / CodeCacheFlushingFraction) + _dead_compile_ids;
 492 
 493   log_sweep("start_cleaning");
 494 
 495   nmethod* nm = CodeCache::alive_nmethod(CodeCache::first());
 496   jint disconnected = 0;
 497   jint made_not_entrant  = 0;
 498   jint nmethod_count = 0;
 499 
 500   while ((nm != NULL)){
 501     int curr_comp_id = nm->compile_id();
 502 
 503     // OSR methods cannot be flushed like this. Also, don't flush native methods
 504     // since they are part of the JDK in most cases
 505     if (!nm->is_osr_method() && !nm->is_locked_by_vm() && !nm->is_native_method()) {
 506 
 507       // only count methods that can be speculatively disconnected


 524           _highest_marked = curr_comp_id;
 525         }
 526       }
 527     }
 528     nm = CodeCache::alive_nmethod(CodeCache::next(nm));
 529   }
 530 
 531   // remember how many compile_ids wheren't seen last flush.
 532   _dead_compile_ids = curr_max_comp_id - nmethod_count;
 533 
 534   log_sweep("stop_cleaning",
 535                        "disconnected='" UINT32_FORMAT "' made_not_entrant='" UINT32_FORMAT "'",
 536                        disconnected, made_not_entrant);
 537 
 538   // Shut off compiler. Sweeper will start over with a new stack scan and
 539   // traversal cycle and turn it back on if it clears enough space.
 540   if (is_full) {
 541     _last_full_flush_time = os::javaTimeMillis();
 542   }
 543 















 544   // After two more traversals the sweeper will get rid of unrestored nmethods
 545   _last_flush_traversal_id = _traversals;
 546   _resweep = true;
 547 #ifdef ASSERT
 548   jlong end = os::javaTimeMillis();
 549   if(PrintMethodFlushing && Verbose) {
 550     tty->print_cr("### sweeper: unload time: " INT64_FORMAT, end-start);
 551   }
 552 #endif
 553 }
 554 
 555 
 556 // Print out some state information about the current sweep and the
 557 // state of the code cache if it's requested.
 558 void NMethodSweeper::log_sweep(const char* msg, const char* format, ...) {
 559   if (PrintMethodFlushing) {
 560     stringStream s;
 561     // Dump code cache state into a buffer before locking the tty,
 562     // because log_state() will use locks causing lock conflicts.
 563     CodeCache::log_state(&s);
 564 
 565     ttyLocker ttyl;
 566     tty->print("### sweeper: %s ", msg);
 567     if (format != NULL) {
 568       va_list ap;
 569       va_start(ap, format);
 570       tty->vprint(format, ap);


   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() {


 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 int       NMethodSweeper::_highest_marked = 0;
 147 int       NMethodSweeper::_dead_compile_ids = 0;
 148 long      NMethodSweeper::_last_flush_traversal_id = 0;
 149 
 150 int       NMethodSweeper::_number_of_flushes = 0; // Total of full traversals caused by full cache
 151 int       NMethodSweeper::_total_nof_methods_reclaimed = 0;
 152 jlong     NMethodSweeper::_total_time_sweeping = 0;
 153 jlong     NMethodSweeper::_total_time_this_sweep = 0;
 154 jlong     NMethodSweeper::_peak_sweep_time = 0;
 155 jlong     NMethodSweeper::_peak_sweep_fraction_time = 0;
 156 jlong     NMethodSweeper::_total_disconnect_time = 0;
 157 jlong     NMethodSweeper::_peak_disconnect_time = 0;
 158 
 159 class MarkActivationClosure: public CodeBlobClosure {
 160 public:
 161   virtual void do_code_blob(CodeBlob* cb) {
 162     // If we see an activation belonging to a non_entrant nmethod, we mark it.
 163     if (cb->is_nmethod() && ((nmethod*)cb)->is_not_entrant()) {
 164       ((nmethod*)cb)->mark_as_seen_on_stack();
 165     }
 166   }
 167 };
 168 static MarkActivationClosure mark_activation_closure;
 169 
 170 bool NMethodSweeper::sweep_in_progress() {
 171   return (_current != NULL);
 172 }
 173 
 174 void NMethodSweeper::scan_stacks() {
 175   assert(SafepointSynchronize::is_at_safepoint(), "must be executed at a safepoint");
 176   if (!MethodFlushing) return;
 177 
 178   // No need to synchronize access, since this is always executed at a
 179   // safepoint.
 180 
 181   // Make sure CompiledIC_lock in unlocked, since we might update some
 182   // inline caches. If it is, we just bail-out and try later.
 183   if (CompiledIC_lock->is_locked() || Patching_lock->is_locked()) return;
 184 
 185   // Check for restart
 186   assert(CodeCache::find_blob_unsafe(_current) == _current, "Sweeper nmethod cached state invalid");
 187   if (!sweep_in_progress() && _resweep) {
 188     _seen        = 0;
 189     _invocations = NmethodSweepFraction;
 190     _current     = CodeCache::first_nmethod();
 191     _traversals  += 1;
 192     _total_time_this_sweep = 0;
 193 
 194     if (PrintMethodFlushing) {
 195       tty->print_cr("### Sweep: stack traversal %d", _traversals);
 196     }
 197     Threads::nmethods_do(&mark_activation_closure);
 198 
 199     // reset the flags since we started a scan from the beginning.
 200     _resweep = false;
 201     _locked_seen = 0;
 202     _not_entrant_seen_on_stack = 0;
 203   }
 204 
 205   if (UseCodeCacheFlushing) {
 206     // only allow new flushes after the interval is complete.
 207     jlong now           = os::javaTimeMillis();
 208     jlong max_interval  = (jlong)MinCodeCacheFlushingInterval * (jlong)1000;
 209     jlong curr_interval = now - _last_full_flush_time;
 210     if (curr_interval > max_interval) {
 211       _flush_token = 0;
 212     }
 213 


 227     jint old = Atomic::cmpxchg( 1, &_sweep_started, 0 );
 228     if (old != 0) {
 229       return;
 230     }
 231 #ifdef ASSERT
 232     if (LogSweeper && _records == NULL) {
 233       // Create the ring buffer for the logging code
 234       _records = NEW_C_HEAP_ARRAY(SweeperRecord, SweeperLogEntries, mtGC);
 235       memset(_records, 0, sizeof(SweeperRecord) * SweeperLogEntries);
 236     }
 237 #endif
 238     if (_invocations > 0) {
 239       sweep_code_cache();
 240       _invocations--;
 241     }
 242     _sweep_started = 0;
 243   }
 244 }
 245 
 246 void NMethodSweeper::sweep_code_cache() {
 247 
 248   jlong sweep_start_counter = os::elapsed_counter();
 249 
 250   _flushed_count   = 0;
 251   _zombified_count = 0;
 252   _marked_count    = 0;
 253 
 254   if (PrintMethodFlushing && Verbose) {
 255     tty->print_cr("### Sweep at %d out of %d. Invocations left: %d", _seen, CodeCache::nof_nmethods(), _invocations);
 256   }
 257 
 258   if (!CompileBroker::should_compile_new_jobs()) {
 259     // If we have turned off compilations we might as well do full sweeps
 260     // in order to reach the clean state faster. Otherwise the sleeping compiler
 261     // threads will slow down sweeping. After a few iterations the cache
 262     // will be clean and sweeping stops (_resweep will not be set)
 263     _invocations = 1;
 264   }
 265 
 266   // We want to visit all nmethods after NmethodSweepFraction
 267   // invocations so divide the remaining number of nmethods by the
 268   // remaining number of invocations.  This is only an estimate since
 269   // the number of nmethods changes during the sweep so the final
 270   // stage must iterate until it there are no more nmethods.
 271   int todo = (CodeCache::nof_nmethods() - _seen) / _invocations;
 272 
 273   assert(!SafepointSynchronize::is_at_safepoint(), "should not be in safepoint when we get here");


 301       }
 302       _seen++;
 303       _current = next;
 304     }
 305   }
 306 
 307   assert(_invocations > 1 || _current == NULL, "must have scanned the whole cache");
 308 
 309   if (!sweep_in_progress() && !_resweep && (_locked_seen || _not_entrant_seen_on_stack)) {
 310     // we've completed a scan without making progress but there were
 311     // nmethods we were unable to process either because they were
 312     // locked or were still on stack.  We don't have to aggresively
 313     // clean them up so just stop scanning.  We could scan once more
 314     // but that complicates the control logic and it's unlikely to
 315     // matter much.
 316     if (PrintMethodFlushing) {
 317       tty->print_cr("### Couldn't make progress on some nmethods so stopping sweep");
 318     }
 319   }
 320 
 321   jlong sweep_end_counter = os::elapsed_counter();
 322   jlong sweep_time = sweep_end_counter - sweep_start_counter;
 323   _total_time_sweeping  += sweep_time;
 324   _total_time_this_sweep += sweep_time;
 325   _peak_sweep_fraction_time = MAX2(sweep_time, _peak_sweep_fraction_time);
 326   _total_nof_methods_reclaimed += _flushed_count;
 327 
 328   EventSweepCodeCache event(UNTIMED);
 329   if (event.should_commit()) {
 330     event.set_starttime(sweep_start_counter);
 331     event.set_endtime(sweep_end_counter);
 332     event.set_sweepIndex(_traversals);
 333     event.set_sweepFractionIndex(NmethodSweepFraction - _invocations + 1);
 334     event.set_sweptCount(todo);
 335     event.set_flushedCount(_flushed_count);
 336     event.set_markedCount(_marked_count);
 337     event.set_zombifiedCount(_zombified_count);
 338     event.commit();
 339   }
 340 
 341 #ifdef ASSERT
 342   if(PrintMethodFlushing) {
 343     tty->print_cr("### sweeper:      sweep time(%d): " INT64_FORMAT, _invocations, (jlong)sweep_time);

 344   }
 345 #endif
 346 
 347   if (_invocations == 1) {
 348     _peak_sweep_time = MAX2(_peak_sweep_time, _total_time_this_sweep);
 349     log_sweep("finished");
 350   }
 351 
 352   // Sweeper is the only case where memory is released,
 353   // check here if it is time to restart the compiler.
 354   if (UseCodeCacheFlushing && !CompileBroker::should_compile_new_jobs() && !CodeCache::needs_flushing()) {
 355     CompileBroker::set_should_compile_new_jobs(CompileBroker::run_compilation);
 356     log_sweep("restart_compiler");
 357   }
 358 }
 359 
 360 class NMethodMarker: public StackObj {
 361  private:
 362   CompilerThread* _thread;
 363  public:
 364   NMethodMarker(nmethod* nm) {
 365     _thread = CompilerThread::current();
 366     if (!nm->is_zombie() && !nm->is_unloaded()) {
 367       // Only expose live nmethods for scanning
 368     _thread->set_scanned_nmethod(nm);


 407       MutexLocker cl(CompiledIC_lock);
 408       nm->cleanup_inline_caches();
 409       SWEEP(nm);
 410     } else {
 411       _locked_seen++;
 412       SWEEP(nm);
 413     }
 414     return;
 415   }
 416 
 417   if (nm->is_zombie()) {
 418     // If it is first time, we see nmethod then we mark it. Otherwise,
 419     // we reclame it. When we have seen a zombie method twice, we know that
 420     // there are no inline caches that refer to it.
 421     if (nm->is_marked_for_reclamation()) {
 422       assert(!nm->is_locked_by_vm(), "must not flush locked nmethods");
 423       if (PrintMethodFlushing && Verbose) {
 424         tty->print_cr("### Nmethod %3d/" PTR_FORMAT " (marked for reclamation) being flushed", nm->compile_id(), nm);
 425       }
 426       release_nmethod(nm);
 427       _flushed_count++;
 428     } else {
 429       if (PrintMethodFlushing && Verbose) {
 430         tty->print_cr("### Nmethod %3d/" PTR_FORMAT " (zombie) being marked for reclamation", nm->compile_id(), nm);
 431       }
 432       nm->mark_for_reclamation();
 433       _resweep = true;
 434       _marked_count++;
 435       SWEEP(nm);
 436     }
 437   } else if (nm->is_not_entrant()) {
 438     // If there is no current activations of this method on the
 439     // stack we can safely convert it to a zombie method
 440     if (nm->can_not_entrant_be_converted()) {
 441       if (PrintMethodFlushing && Verbose) {
 442         tty->print_cr("### Nmethod %3d/" PTR_FORMAT " (not entrant) being made zombie", nm->compile_id(), nm);
 443       }
 444       nm->make_zombie();
 445       _resweep = true;
 446       _zombified_count++;
 447       SWEEP(nm);
 448     } else {
 449       // Still alive, clean up its inline caches
 450       MutexLocker cl(CompiledIC_lock);
 451       nm->cleanup_inline_caches();
 452       // we coudn't transition this nmethod so don't immediately
 453       // request a rescan.  If this method stays on the stack for a
 454       // long time we don't want to keep rescanning the code cache.
 455       _not_entrant_seen_on_stack++;
 456       SWEEP(nm);
 457     }
 458   } else if (nm->is_unloaded()) {
 459     // Unloaded code, just make it a zombie
 460     if (PrintMethodFlushing && Verbose)
 461       tty->print_cr("### Nmethod %3d/" PTR_FORMAT " (unloaded) being made zombie", nm->compile_id(), nm);
 462 
 463     if (nm->is_osr_method()) {
 464       SWEEP(nm);
 465       // No inline caches will ever point to osr methods, so we can just remove it
 466       release_nmethod(nm);
 467       _flushed_count++;
 468     } else {
 469       nm->make_zombie();
 470       _resweep = true;
 471       _zombified_count++;
 472       SWEEP(nm);
 473     }
 474   } else {
 475     assert(nm->is_alive(), "should be alive");
 476 
 477     if (UseCodeCacheFlushing) {
 478       if (nm->is_speculatively_disconnected() && !nm->is_locked_by_vm() && !nm->is_osr_method() &&
 479           (_traversals > _last_flush_traversal_id + 2) && (nm->compile_id() < _highest_marked)) {
 480         // This method has not been called since the forced cleanup happened
 481         nm->make_not_entrant();
 482       }
 483     }
 484 
 485     // Clean-up all inline caches that points to zombie/non-reentrant methods
 486     MutexLocker cl(CompiledIC_lock);
 487     nm->cleanup_inline_caches();
 488     SWEEP(nm);
 489   }
 490 }
 491 


 509 
 510   // Make sure only one thread can flush
 511   // The token is reset after CodeCacheMinimumFlushInterval in scan stacks,
 512   // no need to check the timeout here.
 513   jint old = Atomic::cmpxchg( 1, &_flush_token, 0 );
 514   if (old != 0) {
 515     return;
 516   }
 517 
 518   VM_HandleFullCodeCache op(is_full);
 519   VMThread::execute(&op);
 520 
 521   // resweep again as soon as possible
 522   _resweep = true;
 523 }
 524 
 525 void NMethodSweeper::speculative_disconnect_nmethods(bool is_full) {
 526   // If there was a race in detecting full code cache, only run
 527   // one vm op for it or keep the compiler shut off
 528 
 529   jlong disconnect_start_counter = os::elapsed_counter();
 530 
 531   // Traverse the code cache trying to dump the oldest nmethods
 532   int curr_max_comp_id = CompileBroker::get_compilation_id();
 533   int flush_target = ((curr_max_comp_id - _dead_compile_ids) / CodeCacheFlushingFraction) + _dead_compile_ids;
 534 
 535   log_sweep("start_cleaning");
 536 
 537   nmethod* nm = CodeCache::alive_nmethod(CodeCache::first());
 538   jint disconnected = 0;
 539   jint made_not_entrant  = 0;
 540   jint nmethod_count = 0;
 541 
 542   while ((nm != NULL)){
 543     int curr_comp_id = nm->compile_id();
 544 
 545     // OSR methods cannot be flushed like this. Also, don't flush native methods
 546     // since they are part of the JDK in most cases
 547     if (!nm->is_osr_method() && !nm->is_locked_by_vm() && !nm->is_native_method()) {
 548 
 549       // only count methods that can be speculatively disconnected


 566           _highest_marked = curr_comp_id;
 567         }
 568       }
 569     }
 570     nm = CodeCache::alive_nmethod(CodeCache::next(nm));
 571   }
 572 
 573   // remember how many compile_ids wheren't seen last flush.
 574   _dead_compile_ids = curr_max_comp_id - nmethod_count;
 575 
 576   log_sweep("stop_cleaning",
 577                        "disconnected='" UINT32_FORMAT "' made_not_entrant='" UINT32_FORMAT "'",
 578                        disconnected, made_not_entrant);
 579 
 580   // Shut off compiler. Sweeper will start over with a new stack scan and
 581   // traversal cycle and turn it back on if it clears enough space.
 582   if (is_full) {
 583     _last_full_flush_time = os::javaTimeMillis();
 584   }
 585 
 586   jlong disconnect_end_counter = os::elapsed_counter();
 587   jlong disconnect_time = disconnect_end_counter - disconnect_start_counter;
 588   _total_disconnect_time += disconnect_time;
 589   _peak_disconnect_time = MAX2(disconnect_time, _peak_disconnect_time);
 590 
 591   EventCleanCodeCache event(UNTIMED);
 592   if (event.should_commit()) {
 593     event.set_starttime(disconnect_start_counter);
 594     event.set_endtime(disconnect_end_counter);
 595     event.set_disconnectedCount(disconnected);
 596     event.set_madeNonEntrantCount(made_not_entrant);
 597     event.commit();
 598   }
 599   _number_of_flushes++;
 600 
 601   // After two more traversals the sweeper will get rid of unrestored nmethods
 602   _last_flush_traversal_id = _traversals;
 603   _resweep = true;
 604 #ifdef ASSERT
 605 
 606   if(PrintMethodFlushing && Verbose) {
 607     tty->print_cr("### sweeper: unload time: " INT64_FORMAT, (jlong)disconnect_time);
 608   }
 609 #endif
 610 }
 611 
 612 
 613 // Print out some state information about the current sweep and the
 614 // state of the code cache if it's requested.
 615 void NMethodSweeper::log_sweep(const char* msg, const char* format, ...) {
 616   if (PrintMethodFlushing) {
 617     stringStream s;
 618     // Dump code cache state into a buffer before locking the tty,
 619     // because log_state() will use locks causing lock conflicts.
 620     CodeCache::log_state(&s);
 621 
 622     ttyLocker ttyl;
 623     tty->print("### sweeper: %s ", msg);
 624     if (format != NULL) {
 625       va_list ap;
 626       va_start(ap, format);
 627       tty->vprint(format, ap);