diff --git a/src/share/vm/memory/metaspace.hpp b/src/share/vm/memory/metaspace.hpp index 56197fdd070aaed15232cc778fc6a83768b326fe..f704804795fea4be0939d60fa5a40708a923cb69 100644 --- a/src/share/vm/memory/metaspace.hpp +++ b/src/share/vm/memory/metaspace.hpp @@ -157,16 +157,16 @@ class Metaspace : public CHeapObj { 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) + diff --git a/src/share/vm/memory/universe.cpp b/src/share/vm/memory/universe.cpp index 4406addc9e89bc731a106e2ab704495325926e88..79e092a3b1993c66b0929bc4886b0175495d33f5 100644 --- a/src/share/vm/memory/universe.cpp +++ b/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 diff --git a/src/share/vm/services/memoryManager.cpp b/src/share/vm/services/memoryManager.cpp index d5e54f5ff15a764a28fd4098fd910eb451ed0826..3996d2163c85602e4dde0150b2dd3da43cab3226 100644 --- a/src/share/vm/services/memoryManager.cpp +++ b/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(); } diff --git a/src/share/vm/services/memoryManager.hpp b/src/share/vm/services/memoryManager.hpp index 12c0a0ec458ce0f91fcc338001dcfa74f2d0406f..370d830e9772891a2004ac156e93fd752af4eaf0 100644 --- a/src/share/vm/services/memoryManager.hpp +++ b/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; diff --git a/src/share/vm/services/memoryPool.cpp b/src/share/vm/services/memoryPool.cpp index 969ed7f22bf1ce4f8638d457e3bf8db66fb74bb7..e2895b1f8164381ab8ec5ddc5d19c64b0bb16de8 100644 --- a/src/share/vm/services/memoryPool.cpp +++ b/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; -} diff --git a/src/share/vm/services/memoryPool.hpp b/src/share/vm/services/memoryPool.hpp index f36c3984ced20f599938ae1847ac968bd6b48f08..826061853404de8c0e6eb41306e648d038890ae2 100644 --- a/src/share/vm/services/memoryPool.hpp +++ b/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 diff --git a/src/share/vm/services/memoryService.cpp b/src/share/vm/services/memoryService.cpp index 41f7328d8a8841d243204371bfe261b8b8c3d268..75693dbcf69b2a3f997c5518376fbfd6b638113a 100644 --- a/src/share/vm/services/memoryService.cpp +++ b/src/share/vm/services/memoryService.cpp @@ -60,11 +60,9 @@ GrowableArray* MemoryService::_pools_list = GrowableArray* MemoryService::_managers_list = new (ResourceObj::C_HEAP, mtInternal) GrowableArray(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); diff --git a/src/share/vm/services/memoryService.hpp b/src/share/vm/services/memoryService.hpp index fcd2fdf421dfad960823c03da39eec33531f5552..44cf62ea3cb2655d7362e4d9e27bea215f936f7f 100644 --- a/src/share/vm/services/memoryService.hpp +++ b/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); diff --git a/test/gc/metaspace/TestMetaspaceMemoryPools.java b/test/gc/metaspace/TestMetaspaceMemoryPools.java deleted file mode 100644 index 884f377bc22c5147237b5195619206bf60f0b263..0000000000000000000000000000000000000000 --- a/test/gc/metaspace/TestMetaspaceMemoryPools.java +++ /dev/null @@ -1,75 +0,0 @@ -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 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 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); - } - } -}