src/share/vm/runtime/sweeper.cpp

*** 125,135 ****
  }
  #else
  #define SWEEP(nm)
  #endif
  
! nmethod* NMethodSweeper::_current                      = NULL; // Current nmethod
  long     NMethodSweeper::_traversals                   = 0;    // Stack scan count, also sweep ID.
  long     NMethodSweeper::_total_nof_code_cache_sweeps  = 0;    // Total number of full sweeps of the code cache
  long     NMethodSweeper::_time_counter                 = 0;    // Virtual time used to periodically invoke sweeper
  long     NMethodSweeper::_last_sweep                   = 0;    // Value of _time_counter when the last sweep happened
  int      NMethodSweeper::_seen                         = 0;    // Nof. nmethod we have currently processed in current pass of CodeCache
--- 125,136 ----
  }
  #else
  #define SWEEP(nm)
  #endif
  
! nmethod* NMethodSweeper::_current_nmethod              = NULL; // Current nmethod
! int      NMethodSweeper::_current_type                 = 0;    // Current CodeBlobType
  long     NMethodSweeper::_traversals                   = 0;    // Stack scan count, also sweep ID.
  long     NMethodSweeper::_total_nof_code_cache_sweeps  = 0;    // Total number of full sweeps of the code cache
  long     NMethodSweeper::_time_counter                 = 0;    // Virtual time used to periodically invoke sweeper
  long     NMethodSweeper::_last_sweep                   = 0;    // Value of _time_counter when the last sweep happened
  int      NMethodSweeper::_seen                         = 0;    // Nof. nmethod we have currently processed in current pass of CodeCache
*** 153,186 ****
  Tickspan  NMethodSweeper::_total_time_this_sweep;               // Total time this sweep
  Tickspan  NMethodSweeper::_peak_sweep_time;                     // Peak time for a full sweep
  Tickspan  NMethodSweeper::_peak_sweep_fraction_time;            // Peak time sweeping one fraction
  
  
- 
  class MarkActivationClosure: public CodeBlobClosure {
  public:
    virtual void do_code_blob(CodeBlob* cb) {
!     if (cb->is_nmethod()) {
        nmethod* nm = (nmethod*)cb;
        nm->set_hotness_counter(NMethodSweeper::hotness_counter_reset_val());
        // If we see an activation belonging to a non_entrant nmethod, we mark it.
        if (nm->is_not_entrant()) {
          nm->mark_as_seen_on_stack();
        }
      }
-   }
  };
  static MarkActivationClosure mark_activation_closure;
  
  class SetHotnessClosure: public CodeBlobClosure {
  public:
    virtual void do_code_blob(CodeBlob* cb) {
!     if (cb->is_nmethod()) {
        nmethod* nm = (nmethod*)cb;
        nm->set_hotness_counter(NMethodSweeper::hotness_counter_reset_val());
      }
-   }
  };
  static SetHotnessClosure set_hotness_closure;
  
  
  int NMethodSweeper::hotness_counter_reset_val() {
--- 154,184 ----
  Tickspan NMethodSweeper::_total_time_this_sweep;               // Total time this sweep
  Tickspan NMethodSweeper::_peak_sweep_time;                     // Peak time for a full sweep
  Tickspan NMethodSweeper::_peak_sweep_fraction_time;            // Peak time sweeping one fraction
  
  
  class MarkActivationClosure: public CodeBlobClosure {
  public:
    virtual void do_code_blob(CodeBlob* cb) {
!     assert(cb->is_nmethod(), "CodeBlob should be nmethod");
      nmethod* nm = (nmethod*)cb;
      nm->set_hotness_counter(NMethodSweeper::hotness_counter_reset_val());
      // If we see an activation belonging to a non_entrant nmethod, we mark it.
      if (nm->is_not_entrant()) {
        nm->mark_as_seen_on_stack();
      }
    }
  };
  static MarkActivationClosure mark_activation_closure;
  
  class SetHotnessClosure: public CodeBlobClosure {
  public:
    virtual void do_code_blob(CodeBlob* cb) {
!     assert(cb->is_nmethod(), "CodeBlob should be nmethod");
      nmethod* nm = (nmethod*)cb;
      nm->set_hotness_counter(NMethodSweeper::hotness_counter_reset_val());
    }
  };
  static SetHotnessClosure set_hotness_closure;
  
  
  int NMethodSweeper::hotness_counter_reset_val() {
*** 188,198 ****
      _hotness_counter_reset_val = (ReservedCodeCacheSize < M) ? 1 : (ReservedCodeCacheSize / M) * 2;
    }
    return _hotness_counter_reset_val;
  }
  bool NMethodSweeper::sweep_in_progress() {
!   return (_current != NULL);
  }
  
  // Scans the stacks of all Java threads and marks activations of not-entrant methods.
  // No need to synchronize access, since 'mark_active_nmethods' is always executed at a
  // safepoint.
--- 186,196 ----
      _hotness_counter_reset_val = (ReservedCodeCacheSize < M) ? 1 : (ReservedCodeCacheSize / M) * 2;
    }
    return _hotness_counter_reset_val;
  }
  bool NMethodSweeper::sweep_in_progress() {
!   return (_current_nmethod != NULL);
  }
  
  // Scans the stacks of all Java threads and marks activations of not-entrant methods.
  // No need to synchronize access, since 'mark_active_nmethods' is always executed at a
  // safepoint.
*** 206,220 ****
  
    // Increase time so that we can estimate when to invoke the sweeper again.
    _time_counter++;
  
    // Check for restart
!   assert(CodeCache::find_blob_unsafe(_current) == _current, "Sweeper nmethod cached state invalid");
    if (!sweep_in_progress()) {
      _seen = 0;
      _sweep_fractions_left = NmethodSweepFraction;
!     _current = CodeCache::first_nmethod();
      _traversals += 1;
      _total_time_this_sweep = Tickspan();
  
      if (PrintMethodFlushing) {
        tty->print_cr("### Sweep: stack traversal %d", _traversals);
--- 204,219 ----
  
    // Increase time so that we can estimate when to invoke the sweeper again.
    _time_counter++;
  
    // Check for restart
!   assert(CodeCache::find_blob_unsafe(_current_nmethod) == _current_nmethod, "Sweeper nmethod cached state invalid");
    if (!sweep_in_progress()) {
      _seen = 0;
      _sweep_fractions_left = NmethodSweepFraction;
!     _current_nmethod = (nmethod*)CodeCache::first_blob(CodeBlobType::MethodNonProfiled);
!     _current_type = CodeBlobType::MethodNonProfiled;
      _traversals += 1;
      _total_time_this_sweep = Tickspan();
  
      if (PrintMethodFlushing) {
        tty->print_cr("### Sweep: stack traversal %d", _traversals);
*** 265,275 ****
      // ReservedCodeCacheSize has an 'unsigned' type. We need a 'signed' type for max_wait_time,
      // since 'time_since_last_sweep' can be larger than 'max_wait_time'. If that happens using
      // an unsigned type would cause an underflow (wait_until_next_sweep becomes a large positive
      // value) that disables the intended periodic sweeps.
      const int max_wait_time = ReservedCodeCacheSize / (16 * M);
!     double wait_until_next_sweep = max_wait_time - time_since_last_sweep - CodeCache::reverse_free_ratio();
      assert(wait_until_next_sweep <= (double)max_wait_time, "Calculation of code cache sweeper interval is incorrect");
  
      if ((wait_until_next_sweep <= 0.0) || !CompileBroker::should_compile_new_jobs()) {
        _should_sweep = true;
      }
--- 264,277 ----
      // ReservedCodeCacheSize has an 'unsigned' type. We need a 'signed' type for max_wait_time,
      // since 'time_since_last_sweep' can be larger than 'max_wait_time'. If that happens using
      // an unsigned type would cause an underflow (wait_until_next_sweep becomes a large positive
      // value) that disables the intended periodic sweeps.
      const int max_wait_time = ReservedCodeCacheSize / (16 * M);
!     // Use only signed types
!     double wait_until_next_sweep = max_wait_time - time_since_last_sweep -
!         MAX2(CodeCache::reverse_free_ratio(CodeBlobType::MethodProfiled),
!              CodeCache::reverse_free_ratio(CodeBlobType::MethodNonProfiled));
      assert(wait_until_next_sweep <= (double)max_wait_time, "Calculation of code cache sweeper interval is incorrect");
  
      if ((wait_until_next_sweep <= 0.0) || !CompileBroker::should_compile_new_jobs()) {
        _should_sweep = true;
      }
*** 347,357 ****
    int freed_memory = 0;
    {
      MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
  
      // The last invocation iterates until there are no more nmethods
!     for (int i = 0; (i < todo || _sweep_fractions_left == 1) && _current != NULL; i++) {
        swept_count++;
        if (SafepointSynchronize::is_synchronizing()) { // Safepoint request
          if (PrintMethodFlushing && Verbose) {
            tty->print_cr("### Sweep at %d out of %d, invocation: %d, yielding to safepoint", _seen, CodeCache::nof_nmethods(), _sweep_fractions_left);
          }
--- 349,359 ----
    int freed_memory = 0;
    {
      MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
  
      // The last invocation iterates until there are no more nmethods
!     while ((swept_count < todo || _sweep_fractions_left == 1) && _current_nmethod != NULL) {
        swept_count++;
        if (SafepointSynchronize::is_synchronizing()) { // Safepoint request
          if (PrintMethodFlushing && Verbose) {
            tty->print_cr("### Sweep at %d out of %d, invocation: %d, yielding to safepoint", _seen, CodeCache::nof_nmethods(), _sweep_fractions_left);
          }
*** 363,385 ****
          thread->java_suspend_self();
        }
        // Since we will give up the CodeCache_lock, always skip ahead
        // to the next nmethod.  Other blobs can be deleted by other
        // threads but nmethods are only reclaimed by the sweeper.
!       nmethod* next = CodeCache::next_nmethod(_current);
  
        // Now ready to process nmethod and give up CodeCache_lock
        {
          MutexUnlockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
!         freed_memory += process_nmethod(_current);
        }
        _seen++;
!       _current = next;
      }
    }
  
!   assert(_sweep_fractions_left > 1 || _current == NULL, "must have scanned the whole cache");
  
    const Ticks sweep_end_counter = Ticks::now();
    const Tickspan sweep_time = sweep_end_counter - sweep_start_counter;
    _total_time_sweeping  += sweep_time;
    _total_time_this_sweep += sweep_time;
--- 365,394 ----
          thread->java_suspend_self();
        }
        // Since we will give up the CodeCache_lock, always skip ahead
        // to the next nmethod.  Other blobs can be deleted by other
        // threads but nmethods are only reclaimed by the sweeper.
!       nmethod* next = (nmethod*)CodeCache::next_blob(_current_nmethod, _current_type);
  
        // Now ready to process nmethod and give up CodeCache_lock
        {
          MutexUnlockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
!         freed_memory += process_nmethod(_current_nmethod, _current_type);
        }
        _seen++;
! 
!       while (next == NULL && _current_type < CodeBlobType::MethodProfiled) {
!         // We reached the last method of the type
!         // Go to next type that has methods available
!         _current_type++;
!         next = (nmethod*)CodeCache::first_blob(_current_type);
!       }
!       _current_nmethod = next;
      }
    }
  
!   assert(_sweep_fractions_left > 1 || _current_nmethod == NULL, "must have scanned the whole cache");
  
    const Ticks sweep_end_counter = Ticks::now();
    const Tickspan sweep_time = sweep_end_counter - sweep_start_counter;
    _total_time_sweeping  += sweep_time;
    _total_time_this_sweep += sweep_time;
*** 483,493 ****
  
    MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
    nm->flush();
  }
  
! int NMethodSweeper::process_nmethod(nmethod *nm) {
    assert(!CodeCache_lock->owned_by_self(), "just checking");
  
    int freed_memory = 0;
    // Make sure this nmethod doesn't get unloaded during the scan,
    // since safepoints may happen during acquired below locks.
--- 492,502 ----
  
    MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
    nm->flush();
  }
  
! int NMethodSweeper::process_nmethod(nmethod *nm, int code_blob_type) {
    assert(!CodeCache_lock->owned_by_self(), "just checking");
  
    int freed_memory = 0;
    // Make sure this nmethod doesn't get unloaded during the scan,
    // since safepoints may happen during acquired below locks.
*** 575,585 ****
          nm->dec_hotness_counter();
          // Get the initial value of the hotness counter. This value depends on the
          // ReservedCodeCacheSize
          int reset_val = hotness_counter_reset_val();
          int time_since_reset = reset_val - nm->hotness_counter();
!         double threshold = -reset_val + (CodeCache::reverse_free_ratio() * NmethodSweepActivity);
          // The less free space in the code cache we have - the bigger reverse_free_ratio() is.
          // I.e., 'threshold' increases with lower available space in the code cache and a higher
          // NmethodSweepActivity. If the current hotness counter - which decreases from its initial
          // value until it is reset by stack walking - is smaller than the computed threshold, the
          // corresponding nmethod is considered for removal.
--- 584,594 ----
          nm->dec_hotness_counter();
          // Get the initial value of the hotness counter. This value depends on the
          // ReservedCodeCacheSize
          int reset_val = hotness_counter_reset_val();
          int time_since_reset = reset_val - nm->hotness_counter();
!         double threshold = -reset_val + (CodeCache::reverse_free_ratio(code_blob_type) * NmethodSweepActivity);
          // The less free space in the code cache we have - the bigger reverse_free_ratio() is.
          // I.e., 'threshold' increases with lower available space in the code cache and a higher
          // NmethodSweepActivity. If the current hotness counter - which decreases from its initial
          // value until it is reset by stack walking - is smaller than the computed threshold, the
          // corresponding nmethod is considered for removal.