src/share/vm/runtime/sweeper.cpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File 6996747 Sdiff src/share/vm/runtime

src/share/vm/runtime/sweeper.cpp

Print this page




  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/nmethod.hpp"
  28 #include "compiler/compileBroker.hpp"
  29 #include "memory/resourceArea.hpp"
  30 #include "oops/methodOop.hpp"
  31 #include "runtime/atomic.hpp"
  32 #include "runtime/compilationPolicy.hpp"
  33 #include "runtime/mutexLocker.hpp"
  34 #include "runtime/os.hpp"
  35 #include "runtime/sweeper.hpp"
  36 #include "runtime/vm_operations.hpp"
  37 #include "utilities/events.hpp"
  38 #include "utilities/xmlstream.hpp"
  39 
























































































  40 long      NMethodSweeper::_traversals = 0;   // No. of stack traversals performed
  41 nmethod*  NMethodSweeper::_current = NULL;   // Current nmethod
  42 int       NMethodSweeper::_seen = 0 ;        // No. of nmethods we have currently processed in current pass of CodeCache
  43 
  44 volatile int NMethodSweeper::_invocations = 0;   // No. of invocations left until we are completed with this pass
  45 volatile int NMethodSweeper::_sweep_started = 0; // Whether a sweep is in progress.
  46 
  47 jint      NMethodSweeper::_locked_seen = 0;
  48 jint      NMethodSweeper::_not_entrant_seen_on_stack = 0;
  49 bool      NMethodSweeper::_rescan = false;
  50 bool      NMethodSweeper::_do_sweep = false;
  51 bool      NMethodSweeper::_was_full = false;
  52 jint      NMethodSweeper::_advise_to_sweep = 0;
  53 jlong     NMethodSweeper::_last_was_full = 0;
  54 uint      NMethodSweeper::_highest_marked = 0;
  55 long      NMethodSweeper::_was_full_traversal = 0;
  56 
  57 class MarkActivationClosure: public CodeBlobClosure {
  58 public:
  59   virtual void do_code_blob(CodeBlob* cb) {


 120         // Update the _last_was_full time so we can tell how fast the
 121         // code cache is filling up
 122         _last_was_full = os::javaTimeMillis();
 123 
 124         log_sweep("restart_compiler");
 125       }
 126     }
 127   }
 128 }
 129 
 130 void NMethodSweeper::possibly_sweep() {
 131   assert(JavaThread::current()->thread_state() == _thread_in_vm, "must run in vm mode");
 132   if ((!MethodFlushing) || (!_do_sweep)) return;
 133 
 134   if (_invocations > 0) {
 135     // Only one thread at a time will sweep
 136     jint old = Atomic::cmpxchg( 1, &_sweep_started, 0 );
 137     if (old != 0) {
 138       return;
 139     }







 140     if (_invocations > 0) {
 141       sweep_code_cache();
 142       _invocations--;
 143     }
 144     _sweep_started = 0;
 145   }
 146 }
 147 
 148 void NMethodSweeper::sweep_code_cache() {
 149 #ifdef ASSERT
 150   jlong sweep_start;
 151   if (PrintMethodFlushing) {
 152     sweep_start = os::javaTimeMillis();
 153   }
 154 #endif
 155   if (PrintMethodFlushing && Verbose) {
 156     tty->print_cr("### Sweep at %d out of %d. Invocations left: %d", _seen, CodeCache::nof_nmethods(), _invocations);
 157   }
 158 
 159   // We want to visit all nmethods after NmethodSweepFraction


 196     // clean them up so just stop scanning.  We could scan once more
 197     // but that complicates the control logic and it's unlikely to
 198     // matter much.
 199     if (PrintMethodFlushing) {
 200       tty->print_cr("### Couldn't make progress on some nmethods so stopping sweep");
 201     }
 202   }
 203 
 204 #ifdef ASSERT
 205   if(PrintMethodFlushing) {
 206     jlong sweep_end             = os::javaTimeMillis();
 207     tty->print_cr("### sweeper:      sweep time(%d): " INT64_FORMAT, _invocations, sweep_end - sweep_start);
 208   }
 209 #endif
 210 
 211   if (_invocations == 1) {
 212     log_sweep("finished");
 213   }
 214 }
 215 












 216 

 217 void NMethodSweeper::process_nmethod(nmethod *nm) {
 218   assert(!CodeCache_lock->owned_by_self(), "just checking");
 219 






 220   // Skip methods that are currently referenced by the VM
 221   if (nm->is_locked_by_vm()) {
 222     // But still remember to clean-up inline caches for alive nmethods
 223     if (nm->is_alive()) {
 224       // Clean-up all inline caches that points to zombie/non-reentrant methods
 225       MutexLocker cl(CompiledIC_lock);
 226       nm->cleanup_inline_caches();

 227     } else {
 228       _locked_seen++;

 229     }
 230     return;
 231   }
 232 
 233   if (nm->is_zombie()) {
 234     // If it is first time, we see nmethod then we mark it. Otherwise,
 235     // we reclame it. When we have seen a zombie method twice, we know that
 236     // there are no inline caches that refer to it.
 237     if (nm->is_marked_for_reclamation()) {
 238       assert(!nm->is_locked_by_vm(), "must not flush locked nmethods");
 239       if (PrintMethodFlushing && Verbose) {
 240         tty->print_cr("### Nmethod %3d/" PTR_FORMAT " (marked for reclamation) being flushed", nm->compile_id(), nm);
 241       }
 242       MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
 243       nm->flush();
 244     } else {
 245       if (PrintMethodFlushing && Verbose) {
 246         tty->print_cr("### Nmethod %3d/" PTR_FORMAT " (zombie) being marked for reclamation", nm->compile_id(), nm);
 247       }
 248       nm->mark_for_reclamation();
 249       _rescan = true;

 250     }
 251   } else if (nm->is_not_entrant()) {
 252     // If there is no current activations of this method on the
 253     // stack we can safely convert it to a zombie method
 254     if (nm->can_not_entrant_be_converted()) {
 255       if (PrintMethodFlushing && Verbose) {
 256         tty->print_cr("### Nmethod %3d/" PTR_FORMAT " (not entrant) being made zombie", nm->compile_id(), nm);
 257       }
 258       nm->make_zombie();
 259       _rescan = true;

 260     } else {
 261       // Still alive, clean up its inline caches
 262       MutexLocker cl(CompiledIC_lock);
 263       nm->cleanup_inline_caches();
 264       // we coudn't transition this nmethod so don't immediately
 265       // request a rescan.  If this method stays on the stack for a
 266       // long time we don't want to keep rescanning the code cache.
 267       _not_entrant_seen_on_stack++;

 268     }
 269   } else if (nm->is_unloaded()) {
 270     // Unloaded code, just make it a zombie
 271     if (PrintMethodFlushing && Verbose)
 272       tty->print_cr("### Nmethod %3d/" PTR_FORMAT " (unloaded) being made zombie", nm->compile_id(), nm);
 273     if (nm->is_osr_method()) {
 274       // No inline caches will ever point to osr methods, so we can just remove it
 275       MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);

 276       nm->flush();
 277     } else {
 278       nm->make_zombie();
 279       _rescan = true;

 280     }
 281   } else {
 282     assert(nm->is_alive(), "should be alive");
 283 
 284     if (UseCodeCacheFlushing) {
 285       if ((nm->method()->code() != nm) && !(nm->is_locked_by_vm()) && !(nm->is_osr_method()) &&
 286           (_traversals > _was_full_traversal+2) && (((uint)nm->compile_id()) < _highest_marked) &&
 287           CodeCache::needs_flushing()) {
 288         // This method has not been called since the forced cleanup happened
 289         nm->make_not_entrant();
 290       }
 291     }
 292 
 293     // Clean-up all inline caches that points to zombie/non-reentrant methods
 294     MutexLocker cl(CompiledIC_lock);
 295     nm->cleanup_inline_caches();

 296   }
 297 }
 298 
 299 // Code cache unloading: when compilers notice the code cache is getting full,
 300 // they will call a vm op that comes here. This code attempts to speculatively
 301 // unload the oldest half of the nmethods (based on the compile job id) by
 302 // saving the old code in a list in the CodeCache. Then
 303 // execution resumes. If a method so marked is not called by the second sweeper
 304 // stack traversal after the current one, the nmethod will be marked non-entrant and
 305 // got rid of by normal sweeping. If the method is called, the methodOop's
 306 // _code field is restored and the methodOop/nmethod
 307 // go back to their normal state.
 308 void NMethodSweeper::handle_full_code_cache(bool is_full) {
 309   // Only the first one to notice can advise us to start early cleaning
 310   if (!is_full){
 311     jint old = Atomic::cmpxchg( 1, &_advise_to_sweep, 0 );
 312     if (old != 0) {
 313       return;
 314     }
 315   }




  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/nmethod.hpp"
  28 #include "compiler/compileBroker.hpp"
  29 #include "memory/resourceArea.hpp"
  30 #include "oops/methodOop.hpp"
  31 #include "runtime/atomic.hpp"
  32 #include "runtime/compilationPolicy.hpp"
  33 #include "runtime/mutexLocker.hpp"
  34 #include "runtime/os.hpp"
  35 #include "runtime/sweeper.hpp"
  36 #include "runtime/vm_operations.hpp"
  37 #include "utilities/events.hpp"
  38 #include "utilities/xmlstream.hpp"
  39 
  40 #ifdef ASSERT
  41 
  42 #define SWEEP(nm) record_sweep(nm, __LINE__)
  43 // Sweeper logging code
  44 class SweeperRecord {
  45  public:
  46   int traversal;
  47   int invocation;
  48   int compile_id;
  49   long traversal_mark;
  50   int state;
  51   const char* kind;
  52   address vep;
  53   address uep;
  54   int line;
  55 
  56   void print() {
  57       tty->print_cr("traversal = %d invocation = %d compile_id = %d %s uep = " PTR_FORMAT " vep = "
  58                     PTR_FORMAT " state = %d traversal_mark %d line = %d",
  59                     traversal,
  60                     invocation,
  61                     compile_id,
  62                     kind == NULL ? "" : kind,
  63                     uep,
  64                     vep,
  65                     state,
  66                     traversal_mark,
  67                     line);
  68   }
  69 };
  70 
  71 static uint _sweep_index = 0;
  72 static SweeperRecord* _records = NULL;
  73 
  74 void NMethodSweeper::report_events(int id, address entry) {
  75   if (_records != NULL) {
  76     for (uint i = _sweep_index; i < SweeperLogEntries; i++) {
  77       if (_records[i].uep == entry ||
  78           _records[i].vep == entry ||
  79           _records[i].compile_id == id) {
  80         _records[i].print();
  81       }
  82     }
  83     for (uint i = 0; i < _sweep_index; i++) {
  84       if (_records[i].uep == entry ||
  85           _records[i].vep == entry ||
  86           _records[i].compile_id == id) {
  87         _records[i].print();
  88       }
  89     }
  90   }
  91 }
  92 
  93 void NMethodSweeper::report_events() {
  94   if (_records != NULL) {
  95     for (uint i = _sweep_index; i < SweeperLogEntries; i++) {
  96       // skip empty records
  97       if (_records[i].vep == NULL) continue;
  98       _records[i].print();
  99     }
 100     for (uint i = 0; i < _sweep_index; i++) {
 101       // skip empty records
 102       if (_records[i].vep == NULL) continue;
 103       _records[i].print();
 104     }
 105   }
 106 }
 107 
 108 void NMethodSweeper::record_sweep(nmethod* nm, int line) {
 109   if (_records != NULL) {
 110     _records[_sweep_index].traversal = _traversals;
 111     _records[_sweep_index].traversal_mark = nm->_stack_traversal_mark;
 112     _records[_sweep_index].invocation = _invocations;
 113     _records[_sweep_index].compile_id = nm->compile_id();
 114     _records[_sweep_index].kind = nm->compile_kind();
 115     _records[_sweep_index].state = nm->_state;
 116     _records[_sweep_index].vep = nm->verified_entry_point();
 117     _records[_sweep_index].uep = nm->entry_point();
 118     _records[_sweep_index].line = line;
 119     
 120     _sweep_index = (_sweep_index + 1) % SweeperLogEntries;
 121   }
 122 }
 123 #else
 124 #define SWEEP(nm)
 125 #endif
 126 
 127 
 128 long      NMethodSweeper::_traversals = 0;   // No. of stack traversals performed
 129 nmethod*  NMethodSweeper::_current = NULL;   // Current nmethod
 130 int       NMethodSweeper::_seen = 0 ;        // No. of nmethods we have currently processed in current pass of CodeCache
 131 
 132 volatile int NMethodSweeper::_invocations = 0;   // No. of invocations left until we are completed with this pass
 133 volatile int NMethodSweeper::_sweep_started = 0; // Whether a sweep is in progress.
 134 
 135 jint      NMethodSweeper::_locked_seen = 0;
 136 jint      NMethodSweeper::_not_entrant_seen_on_stack = 0;
 137 bool      NMethodSweeper::_rescan = false;
 138 bool      NMethodSweeper::_do_sweep = false;
 139 bool      NMethodSweeper::_was_full = false;
 140 jint      NMethodSweeper::_advise_to_sweep = 0;
 141 jlong     NMethodSweeper::_last_was_full = 0;
 142 uint      NMethodSweeper::_highest_marked = 0;
 143 long      NMethodSweeper::_was_full_traversal = 0;
 144 
 145 class MarkActivationClosure: public CodeBlobClosure {
 146 public:
 147   virtual void do_code_blob(CodeBlob* cb) {


 208         // Update the _last_was_full time so we can tell how fast the
 209         // code cache is filling up
 210         _last_was_full = os::javaTimeMillis();
 211 
 212         log_sweep("restart_compiler");
 213       }
 214     }
 215   }
 216 }
 217 
 218 void NMethodSweeper::possibly_sweep() {
 219   assert(JavaThread::current()->thread_state() == _thread_in_vm, "must run in vm mode");
 220   if ((!MethodFlushing) || (!_do_sweep)) return;
 221 
 222   if (_invocations > 0) {
 223     // Only one thread at a time will sweep
 224     jint old = Atomic::cmpxchg( 1, &_sweep_started, 0 );
 225     if (old != 0) {
 226       return;
 227     }
 228 #ifdef ASSERT
 229     if (LogSweeper && _records == NULL) {
 230       // Create the ring buffer for the logging code
 231       _records = NEW_C_HEAP_ARRAY(SweeperRecord, SweeperLogEntries);
 232       memset(_records, 0, sizeof(SweeperRecord) * SweeperLogEntries);
 233     }
 234 #endif
 235     if (_invocations > 0) {
 236       sweep_code_cache();
 237       _invocations--;
 238     }
 239     _sweep_started = 0;
 240   }
 241 }
 242 
 243 void NMethodSweeper::sweep_code_cache() {
 244 #ifdef ASSERT
 245   jlong sweep_start;
 246   if (PrintMethodFlushing) {
 247     sweep_start = os::javaTimeMillis();
 248   }
 249 #endif
 250   if (PrintMethodFlushing && Verbose) {
 251     tty->print_cr("### Sweep at %d out of %d. Invocations left: %d", _seen, CodeCache::nof_nmethods(), _invocations);
 252   }
 253 
 254   // We want to visit all nmethods after NmethodSweepFraction


 291     // clean them up so just stop scanning.  We could scan once more
 292     // but that complicates the control logic and it's unlikely to
 293     // matter much.
 294     if (PrintMethodFlushing) {
 295       tty->print_cr("### Couldn't make progress on some nmethods so stopping sweep");
 296     }
 297   }
 298 
 299 #ifdef ASSERT
 300   if(PrintMethodFlushing) {
 301     jlong sweep_end             = os::javaTimeMillis();
 302     tty->print_cr("### sweeper:      sweep time(%d): " INT64_FORMAT, _invocations, sweep_end - sweep_start);
 303   }
 304 #endif
 305 
 306   if (_invocations == 1) {
 307     log_sweep("finished");
 308   }
 309 }
 310 
 311 class NMethodMarker: public StackObj {
 312  private:
 313   CompilerThread* _thread;
 314  public:
 315   NMethodMarker(nmethod* nm) {
 316     _thread = CompilerThread::current();
 317     _thread->set_scanned_nmethod(nm);
 318   }
 319   ~NMethodMarker() {
 320     _thread->set_scanned_nmethod(NULL);
 321   }
 322 };
 323 
 324 
 325 void NMethodSweeper::process_nmethod(nmethod *nm) {
 326   assert(!CodeCache_lock->owned_by_self(), "just checking");
 327 
 328   // Make sure this nmethod doesn't get unloaded during the scan,
 329   // since the locks acquired below might safepoint.
 330   NMethodMarker nmm(nm);
 331 
 332   SWEEP(nm);
 333 
 334   // Skip methods that are currently referenced by the VM
 335   if (nm->is_locked_by_vm()) {
 336     // But still remember to clean-up inline caches for alive nmethods
 337     if (nm->is_alive()) {
 338       // Clean-up all inline caches that points to zombie/non-reentrant methods
 339       MutexLocker cl(CompiledIC_lock);
 340       nm->cleanup_inline_caches();
 341       SWEEP(nm);
 342     } else {
 343       _locked_seen++;
 344       SWEEP(nm);
 345     }
 346     return;
 347   }
 348 
 349   if (nm->is_zombie()) {
 350     // If it is first time, we see nmethod then we mark it. Otherwise,
 351     // we reclame it. When we have seen a zombie method twice, we know that
 352     // there are no inline caches that refer to it.
 353     if (nm->is_marked_for_reclamation()) {
 354       assert(!nm->is_locked_by_vm(), "must not flush locked nmethods");
 355       if (PrintMethodFlushing && Verbose) {
 356         tty->print_cr("### Nmethod %3d/" PTR_FORMAT " (marked for reclamation) being flushed", nm->compile_id(), nm);
 357       }
 358       MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
 359       nm->flush();
 360     } else {
 361       if (PrintMethodFlushing && Verbose) {
 362         tty->print_cr("### Nmethod %3d/" PTR_FORMAT " (zombie) being marked for reclamation", nm->compile_id(), nm);
 363       }
 364       nm->mark_for_reclamation();
 365       _rescan = true;
 366       SWEEP(nm);
 367     }
 368   } else if (nm->is_not_entrant()) {
 369     // If there is no current activations of this method on the
 370     // stack we can safely convert it to a zombie method
 371     if (nm->can_not_entrant_be_converted()) {
 372       if (PrintMethodFlushing && Verbose) {
 373         tty->print_cr("### Nmethod %3d/" PTR_FORMAT " (not entrant) being made zombie", nm->compile_id(), nm);
 374       }
 375       nm->make_zombie();
 376       _rescan = true;
 377       SWEEP(nm);
 378     } else {
 379       // Still alive, clean up its inline caches
 380       MutexLocker cl(CompiledIC_lock);
 381       nm->cleanup_inline_caches();
 382       // we coudn't transition this nmethod so don't immediately
 383       // request a rescan.  If this method stays on the stack for a
 384       // long time we don't want to keep rescanning the code cache.
 385       _not_entrant_seen_on_stack++;
 386       SWEEP(nm);
 387     }
 388   } else if (nm->is_unloaded()) {
 389     // Unloaded code, just make it a zombie
 390     if (PrintMethodFlushing && Verbose)
 391       tty->print_cr("### Nmethod %3d/" PTR_FORMAT " (unloaded) being made zombie", nm->compile_id(), nm);
 392     if (nm->is_osr_method()) {
 393       // No inline caches will ever point to osr methods, so we can just remove it
 394       MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
 395       SWEEP(nm);
 396       nm->flush();
 397     } else {
 398       nm->make_zombie();
 399       _rescan = true;
 400       SWEEP(nm);
 401     }
 402   } else {
 403     assert(nm->is_alive(), "should be alive");
 404 
 405     if (UseCodeCacheFlushing) {
 406       if ((nm->method()->code() != nm) && !(nm->is_locked_by_vm()) && !(nm->is_osr_method()) &&
 407           (_traversals > _was_full_traversal+2) && (((uint)nm->compile_id()) < _highest_marked) &&
 408           CodeCache::needs_flushing()) {
 409         // This method has not been called since the forced cleanup happened
 410         nm->make_not_entrant();
 411       }
 412     }
 413 
 414     // Clean-up all inline caches that points to zombie/non-reentrant methods
 415     MutexLocker cl(CompiledIC_lock);
 416     nm->cleanup_inline_caches();
 417     SWEEP(nm);
 418   }
 419 }
 420 
 421 // Code cache unloading: when compilers notice the code cache is getting full,
 422 // they will call a vm op that comes here. This code attempts to speculatively
 423 // unload the oldest half of the nmethods (based on the compile job id) by
 424 // saving the old code in a list in the CodeCache. Then
 425 // execution resumes. If a method so marked is not called by the second sweeper
 426 // stack traversal after the current one, the nmethod will be marked non-entrant and
 427 // got rid of by normal sweeping. If the method is called, the methodOop's
 428 // _code field is restored and the methodOop/nmethod
 429 // go back to their normal state.
 430 void NMethodSweeper::handle_full_code_cache(bool is_full) {
 431   // Only the first one to notice can advise us to start early cleaning
 432   if (!is_full){
 433     jint old = Atomic::cmpxchg( 1, &_advise_to_sweep, 0 );
 434     if (old != 0) {
 435       return;
 436     }
 437   }


src/share/vm/runtime/sweeper.cpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File