src/hotspot/share/gc/parallel/parallelScavengeHeap.cpp

*** 39,48 ****
--- 39,49 ----
  #include "gc/parallel/psScavenge.hpp"
  #include "gc/parallel/psVMOperations.hpp"
  #include "gc/shared/gcHeapSummary.hpp"
  #include "gc/shared/gcLocker.hpp"
  #include "gc/shared/gcWhen.hpp"
+ #include "gc/shared/scavengableNMethods.hpp"
  #include "logging/log.hpp"
  #include "memory/metaspaceCounters.hpp"
  #include "oops/oop.inline.hpp"
  #include "runtime/handles.inline.hpp"
  #include "runtime/java.hpp"
*** 148,167 ****
--- 149,181 ----
    _young_manager->add_pool(_eden_pool);
    _young_manager->add_pool(_survivor_pool);
  
  }
  
+ namespace {
+   class PSIsScavengable : public BoolObjectClosure {
+     bool do_object_b(oop obj) {
+       return ParallelScavengeHeap::heap()->is_in_young(obj);
+     }
+   };
+ 
+   PSIsScavengable _is_scavengable;
+ }
+ 
+ 
  void ParallelScavengeHeap::post_initialize() {
    CollectedHeap::post_initialize();
    // Need to init the tenuring threshold
    PSScavenge::initialize();
    if (UseParallelOldGC) {
      PSParallelCompact::post_initialize();
    } else {
      PSMarkSweepProxy::initialize();
    }
    PSPromotionManager::initialize();
+ 
+   ScavengableNMethods::initialize(&_is_scavengable);
  }
  
  void ParallelScavengeHeap::update_counters() {
    young_gen()->update_counters();
    old_gen()->update_counters();
*** 695,714 ****
      old_gen()->object_space()->mangle_unused_area();
    }
  }
  #endif
  
! bool ParallelScavengeHeap::is_scavengable(oop obj) {
!   return is_in_young(obj);
  }
  
! void ParallelScavengeHeap::register_nmethod(nmethod* nm) {
!   CodeCache::register_scavenge_root_nmethod(nm);
  }
  
  void ParallelScavengeHeap::verify_nmethod(nmethod* nm) {
!   CodeCache::verify_scavenge_root_nmethod(nm);
  }
  
  GrowableArray<GCMemoryManager*> ParallelScavengeHeap::memory_managers() {
    GrowableArray<GCMemoryManager*> memory_managers(2);
    memory_managers.append(_young_manager);
--- 709,736 ----
      old_gen()->object_space()->mangle_unused_area();
    }
  }
  #endif
  
! void ParallelScavengeHeap::register_nmethod(nmethod* nm) {
!   ScavengableNMethods::register_nmethod(nm);
  }
  
! void ParallelScavengeHeap::unregister_nmethod(nmethod* nm) {
!   ScavengableNMethods::unregister_nmethod(nm);
  }
  
  void ParallelScavengeHeap::verify_nmethod(nmethod* nm) {
!   ScavengableNMethods::verify_nmethod(nm);
! }
! 
! void ParallelScavengeHeap::flush_nmethod(nmethod* nm) {
!   ScavengableNMethods::flush_nmethod(nm);
! }
! 
! void ParallelScavengeHeap::prune_nmethods() {
!   ScavengableNMethods::prune_nmethods();
  }
  
  GrowableArray<GCMemoryManager*> ParallelScavengeHeap::memory_managers() {
    GrowableArray<GCMemoryManager*> memory_managers(2);
    memory_managers.append(_young_manager);