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

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

@@ -31,10 +31,11 @@
 #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,10 +44,11 @@
 #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,5 +674,65 @@
 }
 
 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"; }
+  virtual const char* gc_end_message() { return "end of minor GC"; }
+};
+
+class PSMarkSweepMemoryManager : public GCMemoryManager {
+private:
+public:
+  PSMarkSweepMemoryManager() : GCMemoryManager() {}
+
+  const char* name() { return "PS MarkSweep"; }
+  virtual const char* gc_end_message() { return "end of major GC"; }
+};
+
+GrowableArray<MemoryManager*> ParallelScavengeHeap::memory_managers() {
+  _minor_mgr = new PSScavengeMemoryManager();
+  _major_mgr = new PSMarkSweepMemoryManager();
+  GrowableArray<MemoryManager*> 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;
+}
+