src/share/vm/services/memoryService.cpp

*** 44,61 ****
--- 44,63 ----
  #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,105 ****
--- 98,111 ----
      }
      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,124 ****
--- 119,134 ----
      _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,194 ****
--- 195,213 ----
    _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,392 ****
--- 402,424 ----
  
    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 */);