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

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

*** 21,35 ****
--- 21,95 ----
   * 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;
+ }