src/hotspot/share/gc/serial/serialHeap.cpp

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

@@ -21,15 +21,75 @@
  * questions.
  *
  */
 
 #include "precompiled.hpp"
+#include "gc/serial/defNewGeneration.hpp"
 #include "gc/serial/serialHeap.hpp"
+#include "services/memoryManager.hpp"
+#include "services/memoryPool.hpp"
 
 SerialHeap::SerialHeap(GenCollectorPolicy* policy) : GenCollectedHeap(policy) {}
 
 void SerialHeap::check_gen_kinds() {
   assert(young_gen()->kind() == Generation::DefNew,
          "Wrong youngest generation type");
   assert(old_gen()->kind() == Generation::MarkSweepCompact,
          "Wrong generation kind");
 }
+
+class CopyMemoryManager : public GCMemoryManager {
+private:
+public:
+  CopyMemoryManager() : GCMemoryManager() {}
+
+  const char* name() { return "Copy"; }
+};
+
+class MSCMemoryManager : public GCMemoryManager {
+private:
+public:
+  MSCMemoryManager() : GCMemoryManager() {}
+
+  const char* name() { return "MarkSweepCompact"; }
+};
+
+GrowableArray<GCMemoryManager*> SerialHeap::memory_managers() {
+  _minor_mgr = new CopyMemoryManager();
+  _major_mgr = new MSCMemoryManager();
+  GrowableArray<GCMemoryManager*> mem_mgrs;
+  mem_mgrs.append(_minor_mgr);
+  mem_mgrs.append(_major_mgr);
+  return mem_mgrs;
+}
+
+GrowableArray<MemoryPool*> SerialHeap::memory_pools() {
+  DefNewGeneration* young = (DefNewGeneration*) young_gen();
+
+  // Add a memory pool for each space and young gen doesn't
+  // support low memory detection as it is expected to get filled up.
+  MemoryPool* eden = new ContiguousSpacePool(young->eden(),
+                                             "Eden Space",
+                                             MemoryPool::Heap,
+                                             young->max_eden_size(),
+                                             false /* support_usage_threshold */);
+  MemoryPool* survivor = new SurvivorContiguousSpacePool(young,
+                                                         "Survivor Space",
+                                                         MemoryPool::Heap,
+                                                         young->max_survivor_size(),
+                                                         false /* support_usage_threshold */);
+  GenerationPool* old = new GenerationPool(old_gen(), "Tenured Gen", MemoryPool::Heap, true);
+
+  GrowableArray<MemoryPool*> mem_pools;
+  mem_pools.append(eden);
+  mem_pools.append(survivor);
+  mem_pools.append(old);
+
+  _minor_mgr->add_pool(eden);
+  _minor_mgr->add_pool(survivor);
+
+  _major_mgr->add_pool(eden);
+  _major_mgr->add_pool(survivor);
+  _major_mgr->add_pool(old);
+
+  return mem_pools;
+}