--- a/hotspot/make/linux/makefiles/vm.make Tue Jun 25 14:11:57 2013 +0200
+++ b/hotspot/make/linux/makefiles/vm.make Thu Jun 27 10:56:10 2013 +0200
@@ -107,6 +107,10 @@
# File specific flags
CXXFLAGS += $(CXXFLAGS/BYFILE)
+# Large File Support
+ifneq ($(LP64), 1)
+CXXFLAGS/ostream.o += -D_FILE_OFFSET_BITS=64
+endif # ifneq ($(LP64), 1)
# CFLAGS_WARN holds compiler options to suppress/enable warnings.
CFLAGS += $(CFLAGS_WARN/BYFILE)
--- a/hotspot/make/solaris/makefiles/vm.make Tue Jun 25 14:11:57 2013 +0200
+++ b/hotspot/make/solaris/makefiles/vm.make Thu Jun 27 10:56:10 2013 +0200
@@ -95,6 +95,10 @@
# File specific flags
CXXFLAGS += $(CXXFLAGS/BYFILE)
+# Large File Support
+ifneq ($(LP64), 1)
+CXXFLAGS/ostream.o += -D_FILE_OFFSET_BITS=64
+endif # ifneq ($(LP64), 1)
# CFLAGS_WARN holds compiler options to suppress/enable warnings.
CFLAGS += $(CFLAGS_WARN)
--- a/hotspot/src/os/solaris/vm/os_solaris.inline.hpp Tue Jun 25 14:11:57 2013 +0200
+++ b/hotspot/src/os/solaris/vm/os_solaris.inline.hpp Thu Jun 27 10:56:10 2013 +0200
@@ -89,7 +89,7 @@
inline struct dirent* os::readdir(DIR* dirp, dirent* dbuf) {
assert(dirp != NULL, "just checking");
-#if defined(_LP64) || defined(_GNU_SOURCE)
+#if defined(_LP64) || defined(_GNU_SOURCE) || _FILE_OFFSET_BITS==64
dirent* p;
int status;
@@ -98,9 +98,9 @@
return NULL;
} else
return p;
-#else // defined(_LP64) || defined(_GNU_SOURCE)
+#else // defined(_LP64) || defined(_GNU_SOURCE) || _FILE_OFFSET_BITS==64
return ::readdir_r(dirp, dbuf);
-#endif // defined(_LP64) || defined(_GNU_SOURCE)
+#endif // defined(_LP64) || defined(_GNU_SOURCE) || _FILE_OFFSET_BITS==64
}
inline int os::closedir(DIR *dirp) {
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/asPSOldGen.cpp Tue Jun 25 14:11:57 2013 +0200
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/asPSOldGen.cpp Thu Jun 27 10:56:10 2013 +0200
@@ -70,6 +70,17 @@
_virtual_space = vs;
}
+void ASPSOldGen::initialize_work(const char* perf_data_name, int level) {
+
+ PSOldGen::initialize_work(perf_data_name, level);
+
+ // The old gen can grow to gen_size_limit(). _reserve reflects only
+ // the current maximum that can be committed.
+ assert(_reserved.byte_size() <= gen_size_limit(), "Consistency check");
+
+ initialize_performance_counters(perf_data_name, level);
+}
+
void ASPSOldGen::reset_after_change() {
_reserved = MemRegion((HeapWord*)virtual_space()->low_boundary(),
(HeapWord*)virtual_space()->high_boundary());
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/asPSOldGen.hpp Tue Jun 25 14:11:57 2013 +0200
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/asPSOldGen.hpp Thu Jun 27 10:56:10 2013 +0200
@@ -50,6 +50,8 @@
size_t max_gen_size() { return _reserved.byte_size(); }
void set_gen_size_limit(size_t v) { _gen_size_limit = v; }
+ virtual void initialize_work(const char* perf_data_name, int level);
+
// After a shrink or expand reset the generation
void reset_after_change();
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psOldGen.hpp Tue Jun 25 14:11:57 2013 +0200
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psOldGen.hpp Thu Jun 27 10:56:10 2013 +0200
@@ -110,7 +110,7 @@
virtual void initialize(ReservedSpace rs, size_t alignment,
const char* perf_data_name, int level);
void initialize_virtual_space(ReservedSpace rs, size_t alignment);
- void initialize_work(const char* perf_data_name, int level);
+ virtual void initialize_work(const char* perf_data_name, int level);
virtual void initialize_performance_counters(const char* perf_data_name, int level);
MemRegion reserved() const { return _reserved; }
--- a/hotspot/src/share/vm/memory/metaspace.cpp Tue Jun 25 14:11:57 2013 +0200
+++ b/hotspot/src/share/vm/memory/metaspace.cpp Thu Jun 27 10:56:10 2013 +0200
@@ -1556,19 +1556,7 @@
// ChunkManager methods
-// Verification of _free_chunks_total and _free_chunks_count does not
-// work with the CMS collector because its use of additional locks
-// complicate the mutex deadlock detection but it can still be useful
-// for detecting errors in the chunk accounting with other collectors.
-
size_t ChunkManager::free_chunks_total() {
-#ifdef ASSERT
- if (!UseConcMarkSweepGC && !SpaceManager::expand_lock()->is_locked()) {
- MutexLockerEx cl(SpaceManager::expand_lock(),
- Mutex::_no_safepoint_check_flag);
- slow_locked_verify_free_chunks_total();
- }
-#endif
return _free_chunks_total;
}
@@ -2608,14 +2596,14 @@
"->" SIZE_FORMAT
"(" SIZE_FORMAT ")",
prev_metadata_used,
- allocated_capacity_bytes(),
+ allocated_used_bytes(),
reserved_in_bytes());
} else {
gclog_or_tty->print(" " SIZE_FORMAT "K"
"->" SIZE_FORMAT "K"
"(" SIZE_FORMAT "K)",
prev_metadata_used / K,
- allocated_capacity_bytes() / K,
+ allocated_used_bytes() / K,
reserved_in_bytes()/ K);
}
--- a/hotspot/src/share/vm/memory/universe.cpp Tue Jun 25 14:11:57 2013 +0200
+++ b/hotspot/src/share/vm/memory/universe.cpp Thu Jun 27 10:56:10 2013 +0200
@@ -1127,6 +1127,7 @@
// Initialize performance counters for metaspaces
MetaspaceCounters::initialize_performance_counters();
+ MemoryService::add_metaspace_memory_pools();
GC_locker::unlock(); // allow gc after bootstrapping
--- a/hotspot/src/share/vm/services/management.cpp Tue Jun 25 14:11:57 2013 +0200
+++ b/hotspot/src/share/vm/services/management.cpp Thu Jun 27 10:56:10 2013 +0200
@@ -894,12 +894,6 @@
}
}
- // In our current implementation, we make sure that all non-heap
- // pools have defined init and max sizes. Heap pools do not matter,
- // as we never use total_init and total_max for them.
- assert(heap || !has_undefined_init_size, "Undefined init size");
- assert(heap || !has_undefined_max_size, "Undefined max size");
-
MemoryUsage usage((heap ? InitialHeapSize : total_init),
total_used,
total_committed,
--- a/hotspot/src/share/vm/services/memoryManager.cpp Tue Jun 25 14:11:57 2013 +0200
+++ b/hotspot/src/share/vm/services/memoryManager.cpp Thu Jun 27 10:56:10 2013 +0200
@@ -61,6 +61,10 @@
return (MemoryManager*) new CodeCacheMemoryManager();
}
+MemoryManager* MemoryManager::get_metaspace_memory_manager() {
+ return (MemoryManager*) new MetaspaceMemoryManager();
+}
+
GCMemoryManager* MemoryManager::get_copy_memory_manager() {
return (GCMemoryManager*) new CopyMemoryManager();
}
--- a/hotspot/src/share/vm/services/memoryManager.hpp Tue Jun 25 14:11:57 2013 +0200
+++ b/hotspot/src/share/vm/services/memoryManager.hpp Thu Jun 27 10:56:10 2013 +0200
@@ -56,6 +56,7 @@
enum Name {
Abstract,
CodeCache,
+ Metaspace,
Copy,
MarkSweepCompact,
ParNew,
@@ -88,6 +89,7 @@
// 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();
@@ -108,6 +110,14 @@
const char* name() { return "CodeCacheManager"; }
};
+class MetaspaceMemoryManager : public MemoryManager {
+public:
+ MetaspaceMemoryManager() : MemoryManager() {}
+
+ MemoryManager::Name kind() { return MemoryManager::Metaspace; }
+ const char *name() { return "Metaspace Manager"; }
+};
+
class GCStatInfo : public ResourceObj {
private:
size_t _index;
--- a/hotspot/src/share/vm/services/memoryPool.cpp Tue Jun 25 14:11:57 2013 +0200
+++ b/hotspot/src/share/vm/services/memoryPool.cpp Thu Jun 27 10:56:10 2013 +0200
@@ -25,6 +25,7 @@
#include "precompiled.hpp"
#include "classfile/systemDictionary.hpp"
#include "classfile/vmSymbols.hpp"
+#include "memory/metaspace.hpp"
#include "oops/oop.inline.hpp"
#include "runtime/handles.inline.hpp"
#include "runtime/javaCalls.hpp"
@@ -33,6 +34,7 @@
#include "services/memoryManager.hpp"
#include "services/memoryPool.hpp"
#include "utilities/macros.hpp"
+#include "utilities/globalDefinitions.hpp"
MemoryPool::MemoryPool(const char* name,
PoolType type,
@@ -256,3 +258,39 @@
return MemoryUsage(initial_size(), used, committed, maxSize);
}
+
+MetaspacePool::MetaspacePool() :
+ MemoryPool("Metaspace", NonHeap, capacity_in_bytes(), calculate_max_size(), true, false) { }
+
+MemoryUsage MetaspacePool::get_memory_usage() {
+ size_t committed = align_size_down_(capacity_in_bytes(), os::vm_page_size());
+ return MemoryUsage(initial_size(), used_in_bytes(), committed, max_size());
+}
+
+size_t MetaspacePool::used_in_bytes() {
+ return MetaspaceAux::allocated_used_bytes(Metaspace::NonClassType);
+}
+
+size_t MetaspacePool::capacity_in_bytes() const {
+ return MetaspaceAux::allocated_capacity_bytes(Metaspace::NonClassType);
+}
+
+size_t MetaspacePool::calculate_max_size() const {
+ return FLAG_IS_CMDLINE(MaxMetaspaceSize) ? MaxMetaspaceSize : max_uintx;
+}
+
+CompressedKlassSpacePool::CompressedKlassSpacePool() :
+ MemoryPool("Compressed Class Space", NonHeap, capacity_in_bytes(), ClassMetaspaceSize, true, false) { }
+
+size_t CompressedKlassSpacePool::used_in_bytes() {
+ return MetaspaceAux::allocated_used_bytes(Metaspace::ClassType);
+}
+
+size_t CompressedKlassSpacePool::capacity_in_bytes() const {
+ return MetaspaceAux::allocated_capacity_bytes(Metaspace::ClassType);
+}
+
+MemoryUsage CompressedKlassSpacePool::get_memory_usage() {
+ size_t committed = align_size_down_(capacity_in_bytes(), os::vm_page_size());
+ return MemoryUsage(initial_size(), used_in_bytes(), committed, max_size());
+}
--- a/hotspot/src/share/vm/services/memoryPool.hpp Tue Jun 25 14:11:57 2013 +0200
+++ b/hotspot/src/share/vm/services/memoryPool.hpp Thu Jun 27 10:56:10 2013 +0200
@@ -222,4 +222,21 @@
size_t used_in_bytes() { return _codeHeap->allocated_capacity(); }
};
+class MetaspacePool : public MemoryPool {
+ size_t calculate_max_size() const;
+ size_t capacity_in_bytes() const;
+ public:
+ MetaspacePool();
+ MemoryUsage get_memory_usage();
+ size_t used_in_bytes();
+};
+
+class CompressedKlassSpacePool : public MemoryPool {
+ size_t capacity_in_bytes() const;
+ public:
+ CompressedKlassSpacePool();
+ MemoryUsage get_memory_usage();
+ size_t used_in_bytes();
+};
+
#endif // SHARE_VM_SERVICES_MEMORYPOOL_HPP
--- a/hotspot/src/share/vm/services/memoryService.cpp Tue Jun 25 14:11:57 2013 +0200
+++ b/hotspot/src/share/vm/services/memoryService.cpp Thu Jun 27 10:56:10 2013 +0200
@@ -35,6 +35,7 @@
#include "memory/memRegion.hpp"
#include "memory/tenuredGeneration.hpp"
#include "oops/oop.inline.hpp"
+#include "runtime/globals.hpp"
#include "runtime/javaCalls.hpp"
#include "services/classLoadingService.hpp"
#include "services/lowMemoryDetector.hpp"
@@ -60,9 +61,11 @@
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;
+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::_compressed_class_pool = NULL;
class GcThreadCountClosure: public ThreadClosure {
private:
@@ -399,6 +402,22 @@
_managers_list->append(mgr);
}
+void MemoryService::add_metaspace_memory_pools() {
+ MemoryManager* mgr = MemoryManager::get_metaspace_memory_manager();
+
+ _metaspace_pool = new MetaspacePool();
+ mgr->add_pool(_metaspace_pool);
+ _pools_list->append(_metaspace_pool);
+
+ if (UseCompressedKlassPointers) {
+ _compressed_class_pool = new CompressedKlassSpacePool();
+ mgr->add_pool(_compressed_class_pool);
+ _pools_list->append(_compressed_class_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);
--- a/hotspot/src/share/vm/services/memoryService.hpp Tue Jun 25 14:11:57 2013 +0200
+++ b/hotspot/src/share/vm/services/memoryService.hpp Thu Jun 27 10:56:10 2013 +0200
@@ -73,6 +73,9 @@
// Code heap memory pool
static MemoryPool* _code_heap_pool;
+ static MemoryPool* _metaspace_pool;
+ static MemoryPool* _compressed_class_pool;
+
static void add_generation_memory_pool(Generation* gen,
MemoryManager* major_mgr,
MemoryManager* minor_mgr);
@@ -121,6 +124,7 @@
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);
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/gc/metaspace/TestMetaspaceMemoryPool.java Thu Jun 27 10:56:10 2013 +0200
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+import java.util.List;
+import java.lang.management.ManagementFactory;
+import java.lang.management.MemoryManagerMXBean;
+import java.lang.management.MemoryPoolMXBean;
+import java.lang.management.MemoryUsage;
+
+import java.lang.management.RuntimeMXBean;
+import java.lang.management.ManagementFactory;
+
+/* @test TestMetaspaceMemoryPool
+ * @bug 8000754
+ * @summary Tests that a MemoryPoolMXBeans is created for metaspace and that a
+ * MemoryManagerMXBean is created.
+ * @run main/othervm -XX:+IgnoreUnrecognizedVMOptions -XX:-UseCompressedOops TestMetaspaceMemoryPool
+ * @run main/othervm -XX:+IgnoreUnrecognizedVMOptions -XX:-UseCompressedOops -XX:MaxMetaspaceSize=60m TestMetaspaceMemoryPool
+ * @run main/othervm -XX:+IgnoreUnrecognizedVMOptions -XX:+UseCompressedOops -XX:+UseCompressedKlassPointers TestMetaspaceMemoryPool
+ * @run main/othervm -XX:+IgnoreUnrecognizedVMOptions -XX:+UseCompressedOops -XX:+UseCompressedKlassPointers -XX:ClassMetaspaceSize=60m TestMetaspaceMemoryPool
+ */
+public class TestMetaspaceMemoryPool {
+ public static void main(String[] args) {
+ verifyThatMetaspaceMemoryManagerExists();
+ verifyMemoryPool(getMemoryPool("Metaspace"), isFlagDefined("MaxMetaspaceSize"));
+
+ if (runsOn64bit()) {
+ if (usesCompressedOops()) {
+ MemoryPoolMXBean cksPool = getMemoryPool("Compressed Class Space");
+ verifyMemoryPool(cksPool, true);
+ }
+ }
+ }
+
+ private static boolean runsOn64bit() {
+ return !System.getProperty("sun.arch.data.model").equals("32");
+ }
+
+ private static boolean usesCompressedOops() {
+ return isFlagDefined("+UseCompressedOops");
+ }
+
+ private static boolean isFlagDefined(String name) {
+ RuntimeMXBean runtimeMxBean = ManagementFactory.getRuntimeMXBean();
+ List<String> args = runtimeMxBean.getInputArguments();
+ for (String arg : args) {
+ if (arg.startsWith("-XX:" + name)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private static void verifyThatMetaspaceMemoryManagerExists() {
+ List<MemoryManagerMXBean> managers = ManagementFactory.getMemoryManagerMXBeans();
+ for (MemoryManagerMXBean manager : managers) {
+ if (manager.getName().equals("Metaspace Manager")) {
+ 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) {
+ assertEquals(value, -1, "Expected " + name + " to be undefined");
+ }
+
+ private static void assertEquals(long actual, long expected, String msg) {
+ assertTrue(actual == expected, msg);
+ }
+
+ private static void assertTrue(boolean condition, String msg) {
+ if (!condition) {
+ throw new RuntimeException(msg);
+ }
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/gc/parallelScavenge/AdaptiveGCBoundary.java Thu Jun 27 10:56:10 2013 +0200
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/**
+ * @test AdaptiveGCBoundary
+ * @summary UseAdaptiveGCBoundary is broken
+ * @bug 8014546
+ * @key gc
+ * @key regression
+ * @library /testlibrary
+ * @run main/othervm AdaptiveGCBoundary
+ * @author jon.masamitsu@oracle.com
+ */
+
+import com.oracle.java.testlibrary.*;
+
+public class AdaptiveGCBoundary {
+ public static void main(String args[]) throws Exception {
+
+ ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
+ "-showversion",
+ "-XX:+UseParallelGC",
+ "-XX:+UseAdaptiveGCBoundary",
+ "-XX:+PrintCommandLineFlags",
+ SystemGCCaller.class.getName()
+ );
+
+ OutputAnalyzer output = new OutputAnalyzer(pb.start());
+
+ output.shouldContain("+UseAdaptiveGCBoundary");
+
+ output.shouldNotContain("error");
+
+ output.shouldHaveExitValue(0);
+ }
+ static class SystemGCCaller {
+ public static void main(String [] args) {
+ System.gc();
+ }
+ }
+}