src/share/vm/services/memoryService.cpp

@@ -44,18 +44,20 @@
 #include "services/memoryPool.hpp"
 #include "services/memoryService.hpp"
 #include "utilities/growableArray.hpp"
 #include "utilities/macros.hpp"
 #if INCLUDE_ALL_GCS
+#include "gc/shenandoah/shenandoahHeap.hpp"
 #include "gc/cms/concurrentMarkSweepGeneration.hpp"
 #include "gc/cms/parNewGeneration.hpp"
 #include "gc/g1/g1CollectedHeap.inline.hpp"
 #include "gc/parallel/parallelScavengeHeap.hpp"
 #include "gc/parallel/psOldGen.hpp"
 #include "gc/parallel/psYoungGen.hpp"
 #include "services/g1MemoryPool.hpp"
 #include "services/psMemoryPool.hpp"
+#include "services/shenandoahMemoryPool.hpp"
 #endif // INCLUDE_ALL_GCS
 
 GrowableArray<MemoryPool*>* MemoryService::_pools_list =
   new (ResourceObj::C_HEAP, mtInternal) GrowableArray<MemoryPool*>(init_pools_list_size, true);
 GrowableArray<MemoryManager*>* MemoryService::_managers_list =

@@ -96,10 +98,14 @@
     }
     case CollectedHeap::G1CollectedHeap : {
       add_g1_heap_info(G1CollectedHeap::heap());
       break;
     }
+  case CollectedHeap::ShenandoahHeap : {
+    add_shenandoah_heap_info(ShenandoahHeap::heap());
+    break;
+  }
 #endif // INCLUDE_ALL_GCS
     default: {
       guarantee(false, "Unrecognized kind of heap");
     }
   }

@@ -113,12 +119,16 @@
     _major_gc_manager->set_num_gc_threads(count);
   }
 
   // All memory pools and memory managers are initialized.
   //
+  if (UseShenandoahGC) {
+    _major_gc_manager->initialize_gc_stat_info();
+  } else {
   _minor_gc_manager->initialize_gc_stat_info();
   _major_gc_manager->initialize_gc_stat_info();
+  }
 }
 
 // Add memory pools for GenCollectedHeap
 // This function currently only supports two generations collected heap.
 // The collector for GenCollectedHeap will have two memory managers.

@@ -185,10 +195,19 @@
   _managers_list->append(_major_gc_manager);
 
   add_g1YoungGen_memory_pool(g1h, _major_gc_manager, _minor_gc_manager);
   add_g1OldGen_memory_pool(g1h, _major_gc_manager);
 }
+
+void MemoryService::add_shenandoah_heap_info(ShenandoahHeap* pgch) {
+  assert(UseShenandoahGC, "sanity");
+  _major_gc_manager = MemoryManager::get_shenandoah_memory_manager();
+  _minor_gc_manager = MemoryManager::get_shenandoah_memory_manager();
+  _managers_list->append(_major_gc_manager);
+  add_shenandoah_memory_pool(pgch, _major_gc_manager);
+}
+
 #endif // INCLUDE_ALL_GCS
 
 MemoryPool* MemoryService::add_gen(Generation* gen,
                                    const char* name,
                                    bool is_heap,

@@ -383,10 +402,23 @@
 
   G1OldGenPool* old_gen = new G1OldGenPool(g1h);
   mgr->add_pool(old_gen);
   _pools_list->append(old_gen);
 }
+
+void MemoryService::add_shenandoah_memory_pool(ShenandoahHeap* pgc,
+                                               MemoryManager* mgr) {
+  ShenandoahMemoryPool* pool = new ShenandoahMemoryPool(pgc,
+                                                        "Shenandoah",
+                                                        MemoryPool::Heap,
+                                                        false /* support_usage_threshold */);
+
+  mgr->add_pool(pool);
+  _pools_list->append(pool);
+}
+
+
 #endif // INCLUDE_ALL_GCS
 
 void MemoryService::add_code_heap_memory_pool(CodeHeap* heap, const char* name) {
   // Create new memory pool for this heap
   MemoryPool* code_heap_pool = new CodeHeapPool(heap, name, true /* support_usage_threshold */);