src/hotspot/share/gc/shared/genCollectedHeap.cpp

*** 45,54 ****
--- 45,55 ----
  #include "gc/shared/gcVMOperations.hpp"
  #include "gc/shared/genCollectedHeap.hpp"
  #include "gc/shared/genOopClosures.inline.hpp"
  #include "gc/shared/generationSpec.hpp"
  #include "gc/shared/oopStorageParState.inline.hpp"
+ #include "gc/shared/scavengableNMethods.hpp"
  #include "gc/shared/space.hpp"
  #include "gc/shared/strongRootsScope.hpp"
  #include "gc/shared/weakProcessor.hpp"
  #include "gc/shared/workgroup.hpp"
  #include "memory/filemap.hpp"
*** 173,182 ****
--- 174,194 ----
                         heap_rs->size());
  
    return heap_rs->base();
  }
  
+ namespace {
+   class GenIsScavengable : public BoolObjectClosure {
+   public:
+     bool do_object_b(oop obj) {
+       return GenCollectedHeap::heap()->is_in_young(obj);
+     }
+   };
+ 
+   GenIsScavengable _is_scavengable;
+ }
+ 
  void GenCollectedHeap::post_initialize() {
    CollectedHeap::post_initialize();
    ref_processing_init();
  
    DefNewGeneration* def_new_gen = (DefNewGeneration*)_young_gen;
*** 184,193 ****
--- 196,207 ----
    initialize_size_policy(def_new_gen->eden()->capacity(),
                           _old_gen->capacity(),
                           def_new_gen->from()->capacity());
  
    MarkSweep::initialize();
+ 
+   ScavengableNMethods::initialize(&_is_scavengable);
  }
  
  void GenCollectedHeap::ref_processing_init() {
    _young_gen->ref_processor_init();
    _old_gen->ref_processor_init();
*** 683,697 ****
    ParallelTaskTerminator::print_termination_counts();
  #endif
  }
  
  void GenCollectedHeap::register_nmethod(nmethod* nm) {
!   CodeCache::register_scavenge_root_nmethod(nm);
  }
  
  void GenCollectedHeap::verify_nmethod(nmethod* nm) {
!   CodeCache::verify_scavenge_root_nmethod(nm);
  }
  
  HeapWord* GenCollectedHeap::satisfy_failed_allocation(size_t size, bool is_tlab) {
    GCCauseSetter x(this, GCCause::_allocation_failure);
    HeapWord* result = NULL;
--- 697,723 ----
    ParallelTaskTerminator::print_termination_counts();
  #endif
  }
  
  void GenCollectedHeap::register_nmethod(nmethod* nm) {
!   ScavengableNMethods::register_nmethod(nm);
! }
! 
! void GenCollectedHeap::unregister_nmethod(nmethod* nm) {
!   ScavengableNMethods::unregister_nmethod(nm);
  }
  
  void GenCollectedHeap::verify_nmethod(nmethod* nm) {
!   ScavengableNMethods::verify_nmethod(nm);
! }
! 
! void GenCollectedHeap::flush_nmethod(nmethod* nm) {
!   ScavengableNMethods::flush_nmethod(nm);
! }
! 
! void GenCollectedHeap::prune_nmethods() {
!   ScavengableNMethods::prune_nmethods();
  }
  
  HeapWord* GenCollectedHeap::satisfy_failed_allocation(size_t size, bool is_tlab) {
    GCCauseSetter x(this, GCCause::_allocation_failure);
    HeapWord* result = NULL;
*** 831,841 ****
    if (_process_strong_tasks->try_claim_task(GCH_PS_CodeCache_oops_do)) {
      if (so & SO_ScavengeCodeCache) {
        assert(code_roots != NULL, "must supply closure for code cache");
  
        // We only visit parts of the CodeCache when scavenging.
!       CodeCache::scavenge_root_nmethods_do(code_roots);
      }
      if (so & SO_AllCodeCache) {
        assert(code_roots != NULL, "must supply closure for code cache");
  
        // CMSCollector uses this to do intermediate-strength collections.
--- 857,867 ----
    if (_process_strong_tasks->try_claim_task(GCH_PS_CodeCache_oops_do)) {
      if (so & SO_ScavengeCodeCache) {
        assert(code_roots != NULL, "must supply closure for code cache");
  
        // We only visit parts of the CodeCache when scavenging.
!       ScavengableNMethods::scavengable_nmethods_do(code_roots);
      }
      if (so & SO_AllCodeCache) {
        assert(code_roots != NULL, "must supply closure for code cache");
  
        // CMSCollector uses this to do intermediate-strength collections.
*** 843,853 ****
        CodeCache::blobs_do(code_roots);
      }
      // Verify that the code cache contents are not subject to
      // movement by a scavenging collection.
      DEBUG_ONLY(CodeBlobToOopClosure assert_code_is_non_scavengable(&assert_is_non_scavengable_closure, !CodeBlobToOopClosure::FixRelocations));
!     DEBUG_ONLY(CodeCache::asserted_non_scavengable_nmethods_do(&assert_code_is_non_scavengable));
    }
  }
  
  void GenCollectedHeap::young_process_roots(StrongRootsScope* scope,
                                             OopsInGenClosure* root_closure,
--- 869,879 ----
        CodeCache::blobs_do(code_roots);
      }
      // Verify that the code cache contents are not subject to
      // movement by a scavenging collection.
      DEBUG_ONLY(CodeBlobToOopClosure assert_code_is_non_scavengable(&assert_is_non_scavengable_closure, !CodeBlobToOopClosure::FixRelocations));
!     DEBUG_ONLY(ScavengableNMethods::asserted_non_scavengable_nmethods_do(&assert_code_is_non_scavengable));
    }
  }
  
  void GenCollectedHeap::young_process_roots(StrongRootsScope* scope,
                                             OopsInGenClosure* root_closure,