Merge

hotspot/make/linux/makefiles/vm.make

@@ -107,6 +107,10 @@ CXXFLAGS/BYFILE = $(CXXFLAGS/$@)
 # 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)

hotspot/make/solaris/makefiles/vm.make

@@ -95,6 +95,10 @@ CXXFLAGS/BYFILE = $(CXXFLAGS/$@)
 # 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)

hotspot/src/os/solaris/vm/os_solaris.inline.hpp

@@ -89,7 +89,7 @@ inline int os::readdir_buf_size(const char *path) {
 
 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 @@ inline struct dirent* os::readdir(DIR* dirp, dirent* dbuf) {
     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) {

hotspot/src/share/vm/gc_implementation/parallelScavenge/asPSOldGen.cpp

@@ -70,6 +70,17 @@ ASPSOldGen::ASPSOldGen(PSVirtualSpace* vs,
   _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());

hotspot/src/share/vm/gc_implementation/parallelScavenge/asPSOldGen.hpp

@@ -50,6 +50,8 @@ class ASPSOldGen : public PSOldGen {
   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();
 

hotspot/src/share/vm/gc_implementation/parallelScavenge/psOldGen.hpp

@@ -110,7 +110,7 @@ class PSOldGen : public CHeapObj<mtGC> {
   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; }

hotspot/src/share/vm/memory/metaspace.cpp

@@ -1556,19 +1556,7 @@ bool Metadebug::test_metadata_failure() {
 
 // 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 @@ void MetaspaceAux::print_metaspace_change(size_t prev_metadata_used) {
                         "->" 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);
   }
 

hotspot/src/share/vm/memory/universe.cpp

@@ -1127,6 +1127,7 @@ 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
 

hotspot/src/share/vm/services/management.cpp

@@ -894,12 +894,6 @@ JVM_ENTRY(jobject, jmm_GetMemoryUsage(JNIEnv* env, jboolean heap))
     }
   }
 
-  // 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,

hotspot/src/share/vm/services/memoryManager.cpp

@@ -61,6 +61,10 @@ 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();
 }

hotspot/src/share/vm/services/memoryManager.hpp

@@ -56,6 +56,7 @@ public:
   enum Name {
     Abstract,
     CodeCache,
+    Metaspace,
     Copy,
     MarkSweepCompact,
     ParNew,
@@ -88,6 +89,7 @@ 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();
@@ -108,6 +110,14 @@ public:
   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;

hotspot/src/share/vm/services/memoryPool.cpp

@@ -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 @@ MemoryUsage CodeHeapPool::get_memory_usage() {
 
   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());
+}

hotspot/src/share/vm/services/memoryPool.hpp

@@ -222,4 +222,21 @@ public:
   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

hotspot/src/share/vm/services/memoryService.cpp

@@ -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<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;
+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 @@ void MemoryService::add_code_heap_memory_pool(CodeHeap* heap) {
   _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);

hotspot/src/share/vm/services/memoryService.hpp

@@ -73,6 +73,9 @@ private:
   // 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 @@ 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);

hotspot/test/gc/metaspace/TestMetaspaceMemoryPool.java

@@ -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);
+        }
+    }
+}

hotspot/test/gc/parallelScavenge/AdaptiveGCBoundary.java

@@ -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();
+    }
+  }
+}