*** old/src/share/vm/runtime/sweeper.cpp	Thu Aug 28 12:47:09 2014
--- new/src/share/vm/runtime/sweeper.cpp	Thu Aug 28 12:47:08 2014

*** 129,139 ****
--- 129,139 ----
  }
  #else
  #define SWEEP(nm)
  #endif
  
! nmethod* NMethodSweeper::_current                      = NULL; // Current nmethod
! NMethodIterator NMethodSweeper::_current;                      // 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

*** 157,190 ****
--- 157,187 ----
  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()) {
+     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) {
      if (cb->is_nmethod()) {
+     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() {

*** 192,202 ****
--- 189,199 ----
      _hotness_counter_reset_val = (ReservedCodeCacheSize < M) ? 1 : (ReservedCodeCacheSize / M) * 2;
    }
    return _hotness_counter_reset_val;
  }
  bool NMethodSweeper::sweep_in_progress() {
!   return (_current != NULL);
!   return !_current.end();
  }
  
  // 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.

*** 210,224 ****
--- 207,223 ----
  
    // Increase time so that we can estimate when to invoke the sweeper again.
    _time_counter++;
  
    // Check for restart
!   assert(CodeCache::find_blob_unsafe(_current.method()) == _current.method(), "Sweeper nmethod cached state invalid");
    if (!sweep_in_progress()) {
      _seen = 0;
      _sweep_fractions_left = NmethodSweepFraction;
!     _current = CodeCache::first_nmethod();
!     _current = NMethodIterator();
+     // Initialize to first nmethod
+     _current.next();
      _traversals += 1;
      _total_time_this_sweep = Tickspan();
  
      if (PrintMethodFlushing) {
        tty->print_cr("### Sweep: stack traversal %d", _traversals);

*** 269,279 ****
--- 268,280 ----
      // 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();
+         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;
      }

*** 351,361 ****
--- 352,362 ----
    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++) {
!     while ((swept_count < todo || _sweep_fractions_left == 1) && !_current.end()) {
        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);
          }

*** 367,389 ****
--- 368,390 ----
          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);
!       nmethod* nm = _current.method();
+       _current.next();
  
        // Now ready to process nmethod and give up CodeCache_lock
        {
          MutexUnlockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
!         freed_memory += process_nmethod(_current);
!         freed_memory += process_nmethod(nm);
        }
        _seen++;
        _current = next;
      }
    }
  
!   assert(_sweep_fractions_left > 1 || _current == NULL, "must have scanned the whole cache");
!   assert(_sweep_fractions_left > 1 || _current.end(), "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;

*** 592,602 ****
--- 593,604 ----
        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);
!       int code_blob_type = (CodeCache::get_code_blob_type(nm->comp_level()));
+       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.