8010818: NPG: Remove metaspace memory pools

Reviewed-by: mgerdin, stefank

src/share/vm/memory/metaspace.hpp

@@ -157,16 +157,16 @@ class Metaspace : public CHeapObj<mtClass> {
 
 class MetaspaceAux : AllStatic {
 
-  static size_t free_chunks_total(Metaspace::MetadataType mdtype);
-  static size_t free_chunks_total_in_bytes(Metaspace::MetadataType mdtype);
-
- public:
   // Statistics for class space and data space in metaspace.
   static size_t used_in_bytes(Metaspace::MetadataType mdtype);
   static size_t free_in_bytes(Metaspace::MetadataType mdtype);
   static size_t capacity_in_bytes(Metaspace::MetadataType mdtype);
   static size_t reserved_in_bytes(Metaspace::MetadataType mdtype);
 
+  static size_t free_chunks_total(Metaspace::MetadataType mdtype);
+  static size_t free_chunks_total_in_bytes(Metaspace::MetadataType mdtype);
+
+ public:
   // Total of space allocated to metadata in all Metaspaces
   static size_t used_in_bytes() {
     return used_in_bytes(Metaspace::ClassType) +

src/share/vm/memory/universe.cpp

@@ -1108,7 +1108,6 @@ bool universe_post_init() {
 
   // Initialize performance counters for metaspaces
   MetaspaceCounters::initialize_performance_counters();
-  MemoryService::add_metaspace_memory_pools();
 
   GC_locker::unlock();  // allow gc after bootstrapping
 

src/share/vm/services/memoryManager.cpp

@@ -61,10 +61,6 @@ MemoryManager* MemoryManager::get_code_cache_memory_manager() {
   return (MemoryManager*) new CodeCacheMemoryManager();
 }
 
-MemoryManager* MemoryManager::get_metaspace_memory_manager() {
-  return (MemoryManager*) new MetaspaceMemoryManager();
-}
-
 GCMemoryManager* MemoryManager::get_copy_memory_manager() {
   return (GCMemoryManager*) new CopyMemoryManager();
 }

src/share/vm/services/memoryManager.hpp

@@ -56,7 +56,6 @@ public:
   enum Name {
     Abstract,
     CodeCache,
-    Metaspace,
     Copy,
     MarkSweepCompact,
     ParNew,
@@ -89,7 +88,6 @@ public:
 
   // Static factory methods to get a memory manager of a specific type
   static MemoryManager*   get_code_cache_memory_manager();
-  static MemoryManager*   get_metaspace_memory_manager();
   static GCMemoryManager* get_copy_memory_manager();
   static GCMemoryManager* get_msc_memory_manager();
   static GCMemoryManager* get_parnew_memory_manager();
@@ -110,14 +108,6 @@ public:
   const char* name()         { return "CodeCacheManager"; }
 };
 
-class MetaspaceMemoryManager : public MemoryManager {
-public:
-  MetaspaceMemoryManager() : MemoryManager() {}
-
-  MemoryManager::Name kind() { return MemoryManager::Metaspace; }
-  const char *name()         { return "MetaspaceManager"; }
-};
-
 class GCStatInfo : public ResourceObj {
 private:
   size_t _index;

src/share/vm/services/memoryPool.cpp

@@ -26,15 +26,12 @@
 #include "classfile/systemDictionary.hpp"
 #include "classfile/vmSymbols.hpp"
 #include "oops/oop.inline.hpp"
-#include "runtime/globals.hpp"
 #include "runtime/handles.inline.hpp"
 #include "runtime/javaCalls.hpp"
-#include "runtime/os.hpp"
 #include "services/lowMemoryDetector.hpp"
 #include "services/management.hpp"
 #include "services/memoryManager.hpp"
 #include "services/memoryPool.hpp"
-#include "utilities/globalDefinitions.hpp"
 #include "utilities/macros.hpp"
 
 MemoryPool::MemoryPool(const char* name,
@@ -259,34 +256,3 @@ MemoryUsage CodeHeapPool::get_memory_usage() {
 
   return MemoryUsage(initial_size(), used, committed, maxSize);
 }
-
-MetaspacePoolBase::MetaspacePoolBase(const char *name,
-                                     Metaspace::MetadataType md_type,
-                                     size_t max_size) :
-    _md_type(md_type),
-    MemoryPool(name, NonHeap, MetaspaceAux::capacity_in_bytes(_md_type), max_size,
-               true, false) { }
-
-size_t MetaspacePoolBase::used_in_bytes() {
-  return MetaspaceAux::used_in_bytes(_md_type);
-}
-
-MemoryUsage MetaspacePoolBase::get_memory_usage() {
-  size_t used = MetaspaceAux::used_in_bytes(_md_type);
-  size_t committed = align_size_down_(MetaspaceAux::capacity_in_bytes(_md_type), os::vm_page_size());
-  return MemoryUsage(initial_size(), used, committed, max_size());
-}
-
-ClassMetaspacePool::ClassMetaspacePool() :
-    MetaspacePoolBase("Class Metaspace", Metaspace::ClassType, calculate_max_size()) { }
-
-size_t ClassMetaspacePool::calculate_max_size() {
-  return UseCompressedKlassPointers ? ClassMetaspaceSize : _undefined_max_size;
-}
-
-MetaspacePool::MetaspacePool() :
-    MetaspacePoolBase("Metaspace", Metaspace::NonClassType, calculate_max_size()) { }
-
-size_t MetaspacePool::calculate_max_size() {
-  return FLAG_IS_CMDLINE(MaxMetaspaceSize) ? MaxMetaspaceSize : _undefined_max_size;
-}

src/share/vm/services/memoryPool.hpp

@@ -28,7 +28,6 @@
 #include "gc_implementation/shared/mutableSpace.hpp"
 #include "memory/defNewGeneration.hpp"
 #include "memory/heap.hpp"
-#include "memory/metaspace.hpp"
 #include "memory/space.hpp"
 #include "services/memoryUsage.hpp"
 #include "utilities/macros.hpp"
@@ -223,29 +222,4 @@ public:
   size_t used_in_bytes()            { return _codeHeap->allocated_capacity(); }
 };
 
-class MetaspacePoolBase : public MemoryPool {
-private:
-  Metaspace::MetadataType _md_type;
-protected:
-  static const size_t _undefined_max_size = (size_t) -1;
-public:
-  MetaspacePoolBase(const char *name, Metaspace::MetadataType md_type, size_t max_size);
-  MemoryUsage get_memory_usage();
-  size_t used_in_bytes();
-};
-
-class ClassMetaspacePool : public MetaspacePoolBase {
-private:
-  size_t calculate_max_size();
-public:
-  ClassMetaspacePool();
-};
-
-class MetaspacePool : public MetaspacePoolBase {
-private:
-  size_t calculate_max_size();
-public:
-  MetaspacePool();
-};
-
 #endif // SHARE_VM_SERVICES_MEMORYPOOL_HPP

src/share/vm/services/memoryService.cpp

@@ -60,11 +60,9 @@ GrowableArray<MemoryPool*>* MemoryService::_pools_list =
 GrowableArray<MemoryManager*>* MemoryService::_managers_list =
   new (ResourceObj::C_HEAP, mtInternal) GrowableArray<MemoryManager*>(init_managers_list_size, true);
 
-GCMemoryManager* MemoryService::_minor_gc_manager     = NULL;
-GCMemoryManager* MemoryService::_major_gc_manager     = NULL;
-MemoryPool*      MemoryService::_code_heap_pool       = NULL;
-MemoryPool*      MemoryService::_metaspace_pool       = NULL;
-MemoryPool*      MemoryService::_class_metaspace_pool = NULL;
+GCMemoryManager* MemoryService::_minor_gc_manager = NULL;
+GCMemoryManager* MemoryService::_major_gc_manager = NULL;
+MemoryPool*      MemoryService::_code_heap_pool   = NULL;
 
 class GcThreadCountClosure: public ThreadClosure {
  private:
@@ -401,19 +399,6 @@ void MemoryService::add_code_heap_memory_pool(CodeHeap* heap) {
   _managers_list->append(mgr);
 }
 
-void MemoryService::add_metaspace_memory_pools() {
-  _metaspace_pool = new MetaspacePool();
-  _class_metaspace_pool = new ClassMetaspacePool();
-
-  MemoryManager* mgr = MemoryManager::get_metaspace_memory_manager();
-  mgr->add_pool(_metaspace_pool);
-  mgr->add_pool(_class_metaspace_pool);
-
-  _pools_list->append(_metaspace_pool);
-  _pools_list->append(_class_metaspace_pool);
-  _managers_list->append(mgr);
-}
-
 MemoryManager* MemoryService::get_memory_manager(instanceHandle mh) {
   for (int i = 0; i < _managers_list->length(); i++) {
     MemoryManager* mgr = _managers_list->at(i);

src/share/vm/services/memoryService.hpp

@@ -73,10 +73,6 @@ private:
   // Code heap memory pool
   static MemoryPool*                    _code_heap_pool;
 
-  // Metaspace pools
-  static MemoryPool*                    _metaspace_pool;
-  static MemoryPool*                    _class_metaspace_pool;
-
   static void add_generation_memory_pool(Generation* gen,
                                          MemoryManager* major_mgr,
                                          MemoryManager* minor_mgr);
@@ -125,7 +121,6 @@ private:
 public:
   static void set_universe_heap(CollectedHeap* heap);
   static void add_code_heap_memory_pool(CodeHeap* heap);
-  static void add_metaspace_memory_pools();
 
   static MemoryPool*    get_memory_pool(instanceHandle pool);
   static MemoryManager* get_memory_manager(instanceHandle mgr);

test/gc/metaspace/TestMetaspaceMemoryPools.java

-import java.util.List;
-import java.lang.management.ManagementFactory;
-import java.lang.management.MemoryManagerMXBean;
-import java.lang.management.MemoryPoolMXBean;
-import java.lang.management.MemoryUsage;
-
-/* @test TestMetaspaceMemoryPools
- * @bug 8000754
- * @summary Tests that two MemoryPoolMXBeans are created, one for metaspace and
- *          one for class metaspace, is created and that a MemoryManagerMXBean
- *          is created.
- * @run main/othervm TestMetaspaceMemoryPools defined undefined
- * @run main/othervm -XX:-UseCompressedKlassPointers TestMetaspaceMemoryPools undefined undefined
- * @run main/othervm -XX:-UseCompressedKlassPointers -XX:MaxMetaspaceSize=60m TestMetaspaceMemoryPools undefined defined
- */
-public class TestMetaspaceMemoryPools {
-    public static void main(String[] args) {
-        boolean isClassMetaspaceMaxDefined = args[0].equals("defined");
-        boolean isMetaspaceMaxDefined = args[1].equals("defined");
-
-        verifyThatMetaspaceMemoryManagerExists();
-
-        verifyMemoryPool(getMemoryPool("Class Metaspace"), isClassMetaspaceMaxDefined);
-        verifyMemoryPool(getMemoryPool("Metaspace"), isMetaspaceMaxDefined);
-    }
-
-    private static void verifyThatMetaspaceMemoryManagerExists() {
-        List<MemoryManagerMXBean> managers = ManagementFactory.getMemoryManagerMXBeans();
-        for (MemoryManagerMXBean manager : managers) {
-            if (manager.getName().equals("MetaspaceManager")) {
-                return;
-            }
-        }
-
-        throw new RuntimeException("Expected to find a metaspace memory manager");
-    }
-
-    private static MemoryPoolMXBean getMemoryPool(String name) {
-        List<MemoryPoolMXBean> pools = ManagementFactory.getMemoryPoolMXBeans();
-        for (MemoryPoolMXBean pool : pools) {
-            if (pool.getName().equals(name)) {
-                return pool;
-            }
-        }
-
-        throw new RuntimeException("Expected to find a memory pool with name " + name);
-    }
-
-    private static void verifyMemoryPool(MemoryPoolMXBean pool, boolean isMaxDefined) {
-        MemoryUsage mu = pool.getUsage();
-        assertDefined(mu.getInit(), "init");
-        assertDefined(mu.getUsed(), "used");
-        assertDefined(mu.getCommitted(), "committed");
-
-        if (isMaxDefined) {
-            assertDefined(mu.getMax(), "max");
-        } else {
-            assertUndefined(mu.getMax(), "max");
-        }
-    }
-
-    private static void assertDefined(long value, String name) {
-        assertTrue(value != -1, "Expected " + name + " to be defined");
-    }
-
-    private static void assertUndefined(long value, String name) {
-        assertTrue(value == -1, "Expected " + name + " to be undefined");
-    }
-
-    private static void assertTrue(boolean condition, String msg) {
-        if (!condition) {
-            throw new RuntimeException(msg);
-        }
-    }
-}