src/hotspot/share/gc/cms/cmsHeap.cpp

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

@@ -21,18 +21,23 @@
  * questions.
  *
  */
 
 #include "precompiled.hpp"
+#include "gc/cms/compactibleFreeListSpace.hpp"
+#include "gc/cms/concurrentMarkSweepGeneration.hpp"
 #include "gc/cms/concurrentMarkSweepThread.hpp"
 #include "gc/cms/cmsHeap.hpp"
+#include "gc/cms/parNewGeneration.hpp"
 #include "gc/cms/vmCMSOperations.hpp"
 #include "gc/shared/genOopClosures.inline.hpp"
 #include "gc/shared/strongRootsScope.hpp"
 #include "gc/shared/workgroup.hpp"
 #include "oops/oop.inline.hpp"
 #include "runtime/vmThread.hpp"
+#include "services/memoryManager.hpp"
+#include "services/memoryPool.hpp"
 #include "utilities/stack.inline.hpp"
 
 CMSHeap::CMSHeap(GenCollectorPolicy *policy) : GenCollectedHeap(policy) {
   _workers = new WorkGang("GC Thread", ParallelGCThreads,
                           /* are_GC_task_threads */true,

@@ -181,5 +186,84 @@
 
 void CMSHeap::gc_epilogue(bool full) {
   GenCollectedHeap::gc_epilogue(full);
   always_do_update_barrier = true;
 };
+
+class ParNewMemoryManager : public GCMemoryManager {
+private:
+public:
+  ParNewMemoryManager() : GCMemoryManager() {}
+
+  const char* name() { return "ParNew"; }
+  virtual const char* gc_end_message() { return "end of major GC"; }
+};
+
+class CMSMemoryManager : public GCMemoryManager {
+private:
+public:
+  CMSMemoryManager() : GCMemoryManager() {}
+
+  const char* name() { return "ConcurrentMarkSweep";}
+  virtual const char* gc_end_message() { return "end of minor GC"; }
+};
+
+class CompactibleFreeListSpacePool : public CollectedMemoryPool {
+private:
+  CompactibleFreeListSpace* _space;
+public:
+  CompactibleFreeListSpacePool(CompactibleFreeListSpace* space,
+                               const char* name,
+                               PoolType type,
+                               size_t max_size,
+                               bool support_usage_threshold) :
+    CollectedMemoryPool(name, type, space->capacity(), max_size,
+                        support_usage_threshold), _space(space) {
+  }
+
+  MemoryUsage get_memory_usage() {
+    size_t maxSize   = (available_for_allocation() ? max_size() : 0);
+    size_t used      = used_in_bytes();
+    size_t committed = _space->capacity();
+    
+    return MemoryUsage(initial_size(), used, committed, maxSize);
+  }
+
+  size_t used_in_bytes() {
+    return _space->used();
+  }
+};
+
+void CMSHeap::init_memory_managers() {
+  _minor_mgr = new ParNewMemoryManager();
+  _major_mgr = new CMSMemoryManager();
+}
+
+GrowableArray<MemoryManager*> CMSHeap::memory_managers() {
+  GrowableArray<MemoryManager*> cms_memory_managers;
+  cms_memory_managers.append(_minor_mgr);
+  cms_memory_managers.append(_major_mgr);
+  return cms_memory_managers;
+}
+
+GrowableArray<MemoryPool*> CMSHeap::memory_pools() {
+  GrowableArray<MemoryPool*> cms_memory_pools;
+
+  ParNewGeneration* young = (ParNewGeneration*) young_gen();
+  ContiguousSpacePool* eden = new ContiguousSpacePool(young->eden(), "Par Eden Space", MemoryPool::Heap, young->max_eden_size(), false);
+  SurvivorContiguousSpacePool* survivor = new SurvivorContiguousSpacePool(young, "Par Survivor Space", MemoryPool::Heap, young->max_survivor_size(), false);
+
+  ConcurrentMarkSweepGeneration* cms = (ConcurrentMarkSweepGeneration*) old_gen();
+  CompactibleFreeListSpacePool* old = new CompactibleFreeListSpacePool(cms->cmsSpace(), "CMS Old Gen", MemoryPool::Heap, cms->reserved().byte_size(), true);
+
+  cms_memory_pools.append(eden);
+  cms_memory_pools.append(survivor);
+  cms_memory_pools.append(old);
+
+  _minor_mgr->add_pool(eden);
+  _major_mgr->add_pool(eden);
+  _minor_mgr->add_pool(survivor);
+  _major_mgr->add_pool(survivor);
+  _major_mgr->add_pool(old);
+
+  return cms_memory_pools;
+}