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

rev 47884 : 8191564: Refactor GC related servicability code into GC specific subclasses

*** 31,40 ****
--- 31,41 ----
  #include "gc/parallel/generationSizer.hpp"
  #include "gc/parallel/objectStartArray.inline.hpp"
  #include "gc/parallel/parallelScavengeHeap.inline.hpp"
  #include "gc/parallel/psAdaptiveSizePolicy.hpp"
  #include "gc/parallel/psMarkSweep.hpp"
+ #include "gc/parallel/psMemoryPool.hpp"
  #include "gc/parallel/psParallelCompact.inline.hpp"
  #include "gc/parallel/psPromotionManager.hpp"
  #include "gc/parallel/psScavenge.hpp"
  #include "gc/parallel/vmPSOperations.hpp"
  #include "gc/shared/gcHeapSummary.hpp"
*** 43,52 ****
--- 44,54 ----
  #include "logging/log.hpp"
  #include "oops/oop.inline.hpp"
  #include "runtime/handles.inline.hpp"
  #include "runtime/java.hpp"
  #include "runtime/vmThread.hpp"
+ #include "services/memoryManager.hpp"
  #include "services/memTracker.hpp"
  #include "utilities/vmError.hpp"
  
  PSYoungGen*  ParallelScavengeHeap::_young_gen = NULL;
  PSOldGen*    ParallelScavengeHeap::_old_gen = NULL;
*** 672,676 ****
--- 674,736 ----
  }
  
  void ParallelScavengeHeap::verify_nmethod(nmethod* nm) {
    CodeCache::verify_scavenge_root_nmethod(nm);
  }
+ 
+ class PSScavengeMemoryManager : public GCMemoryManager {
+ private:
+ public:
+   PSScavengeMemoryManager() : GCMemoryManager() {}
+ 
+   const char* name() { return "PS Scavenge"; }
+ };
+ 
+ class PSMarkSweepMemoryManager : public GCMemoryManager {
+ private:
+ public:
+   PSMarkSweepMemoryManager() : GCMemoryManager() {}
+ 
+   const char* name() { return "PS MarkSweep"; }
+ };
+ 
+ GrowableArray<GCMemoryManager*> ParallelScavengeHeap::memory_managers() {
+   _minor_mgr = new PSScavengeMemoryManager();
+   _major_mgr = new PSMarkSweepMemoryManager();
+   GrowableArray<GCMemoryManager*> mem_mgrs;
+   mem_mgrs.append(_minor_mgr);
+   mem_mgrs.append(_major_mgr);
+   return mem_mgrs;
+ }
+ 
+ GrowableArray<MemoryPool*> ParallelScavengeHeap::memory_pools() {
+   PSYoungGen* young = young_gen();
+   EdenMutableSpacePool* eden = new EdenMutableSpacePool(young,
+                                                         young->eden_space(),
+                                                         "PS Eden Space",
+                                                         MemoryPool::Heap,
+                                                         false /* support_usage_threshold */);
+ 
+   SurvivorMutableSpacePool* survivor = new SurvivorMutableSpacePool(young,
+                                                                     "PS Survivor Space",
+                                                                     MemoryPool::Heap,
+                                                                     false /* support_usage_threshold */);
+ 
+   PSGenerationPool* old_gen_pool = new PSGenerationPool(old_gen(),
+                                                        "PS Old Gen",
+                                                        MemoryPool::Heap,
+                                                        true /* support_usage_threshold */);
+ 
+   _major_mgr->add_pool(eden);
+   _major_mgr->add_pool(survivor);
+   _major_mgr->add_pool(old_gen_pool);
+ 
+   _minor_mgr->add_pool(eden);
+   _minor_mgr->add_pool(survivor);
+ 
+   GrowableArray<MemoryPool*> mem_pools;
+   mem_pools.append(eden);
+   mem_pools.append(survivor);
+   mem_pools.append(old_gen_pool);
+   return mem_pools;
+ }
+