changeset 6713:90b8f9f6c793

Merge
author coleenp
date Wed, 02 Jul 2014 20:20:45 -0400
parents 08a2164660fb 995ffec25fac
children 35de71d2af77 22b98ab2a69f
files src/share/vm/gc_implementation/parallelScavenge/parMarkBitMap.cpp src/share/vm/prims/jni.cpp src/share/vm/runtime/os.cpp src/share/vm/runtime/os.hpp src/share/vm/runtime/virtualspace.cpp
diffstat 14 files changed, 72 insertions(+), 94 deletions(-) [+]
line wrap: on
line diff
--- a/make/linux/Makefile	Thu Jun 26 16:05:15 2014 +0200
+++ b/make/linux/Makefile	Wed Jul 02 20:20:45 2014 -0400
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 1999, 2014, 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
@@ -67,8 +67,12 @@
   endif
 endif
 # C1 is not ported on ppc64, so we cannot build a tiered VM:
-ifeq ($(ARCH),ppc64)
-  FORCE_TIERED=0
+# Notice: after 8046471 ARCH will be 'ppc' for top-level ppc64 builds but
+# 'ppc64' for HotSpot-only ppc64 builds. Need to detect both variants here!
+ifneq (,$(findstring $(ARCH), ppc ppc64))
+  ifeq ($(ARCH_DATA_MODEL), 64)
+    FORCE_TIERED=0
+  endif
 endif
 
 ifdef LP64
--- a/make/linux/makefiles/defs.make	Thu Jun 26 16:05:15 2014 +0200
+++ b/make/linux/makefiles/defs.make	Wed Jul 02 20:20:45 2014 -0400
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2006, 2013, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2006, 2014, 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
@@ -108,7 +108,9 @@
 endif
 
 # PPC
-ifneq (,$(findstring $(ARCH), ppc))
+# Notice: after 8046471 ARCH will be 'ppc' for top-level ppc64 builds but
+# 'ppc64' for HotSpot-only ppc64 builds. Need to detect both variants here!
+ifneq (,$(findstring $(ARCH), ppc ppc64))
   ifeq ($(ARCH_DATA_MODEL), 64)
     MAKE_ARGS        += LP64=1
     PLATFORM         = linux-ppc64
--- a/src/share/vm/classfile/javaClasses.cpp	Thu Jun 26 16:05:15 2014 +0200
+++ b/src/share/vm/classfile/javaClasses.cpp	Wed Jul 02 20:20:45 2014 -0400
@@ -618,6 +618,8 @@
       assert(comp_mirror.not_null(), "must have a mirror");
 
       // Two-way link between the array klass and its component mirror:
+      // (array_klass) k -> mirror -> component_mirror -> array_klass -> k
+      set_component_mirror(mirror(), comp_mirror());
       ArrayKlass::cast(k())->set_component_mirror(comp_mirror());
       set_array_klass(comp_mirror(), k());
     } else {
@@ -679,6 +681,16 @@
   java_class->obj_field_put(_protection_domain_offset, pd);
 }
 
+void java_lang_Class::set_component_mirror(oop java_class, oop comp_mirror) {
+  if (_component_mirror_offset != 0) {
+    java_class->obj_field_put(_component_mirror_offset, comp_mirror);
+  }
+}
+oop java_lang_Class::component_mirror(oop java_class) {
+  assert(_component_mirror_offset != 0, "must be set");
+  return java_class->obj_field(_component_mirror_offset);
+}
+
 oop java_lang_Class::init_lock(oop java_class) {
   assert(_init_lock_offset != 0, "must be set");
   return java_class->obj_field(_init_lock_offset);
@@ -875,6 +887,10 @@
                  klass_oop, vmSymbols::classLoader_name(),
                  vmSymbols::classloader_signature());
 
+  compute_optional_offset(_component_mirror_offset,
+                 klass_oop, vmSymbols::componentType_name(),
+                 vmSymbols::class_signature());
+
   CLASS_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
 }
 
@@ -3097,6 +3113,7 @@
 int java_lang_Class::_static_oop_field_count_offset;
 int java_lang_Class::_class_loader_offset;
 int java_lang_Class::_protection_domain_offset;
+int java_lang_Class::_component_mirror_offset;
 int java_lang_Class::_init_lock_offset;
 int java_lang_Class::_signers_offset;
 GrowableArray<Klass*>* java_lang_Class::_fixup_mirror_list = NULL;
--- a/src/share/vm/classfile/javaClasses.hpp	Thu Jun 26 16:05:15 2014 +0200
+++ b/src/share/vm/classfile/javaClasses.hpp	Wed Jul 02 20:20:45 2014 -0400
@@ -241,6 +241,7 @@
   static int _init_lock_offset;
   static int _signers_offset;
   static int _class_loader_offset;
+  static int _component_mirror_offset;
 
   static bool offsets_computed;
   static int classRedefinedCount_offset;
@@ -250,6 +251,7 @@
   static void set_init_lock(oop java_class, oop init_lock);
   static void set_protection_domain(oop java_class, oop protection_domain);
   static void set_class_loader(oop java_class, oop class_loader);
+  static void set_component_mirror(oop java_class, oop comp_mirror);
   static void initialize_mirror_fields(KlassHandle k, Handle mirror, Handle protection_domain, TRAPS);
  public:
   static void compute_offsets();
@@ -291,6 +293,7 @@
   // Support for embedded per-class oops
   static oop  protection_domain(oop java_class);
   static oop  init_lock(oop java_class);
+  static oop  component_mirror(oop java_class);
   static objArrayOop  signers(oop java_class);
   static void set_signers(oop java_class, objArrayOop signers);
 
--- a/src/share/vm/classfile/vmSymbols.hpp	Thu Jun 26 16:05:15 2014 +0200
+++ b/src/share/vm/classfile/vmSymbols.hpp	Wed Jul 02 20:20:45 2014 -0400
@@ -573,6 +573,7 @@
   template(serializeAgentPropertiesToByteArray_name,   "serializeAgentPropertiesToByteArray")                     \
   template(classRedefinedCount_name,                   "classRedefinedCount")                                     \
   template(classLoader_name,                           "classLoader")                                             \
+  template(componentType_name,                         "componentType")                                           \
                                                                                                                   \
   /* trace signatures */                                                                                          \
   TRACE_TEMPLATES(template)                                                                                       \
--- a/src/share/vm/gc_implementation/parallelScavenge/generationSizer.cpp	Thu Jun 26 16:05:15 2014 +0200
+++ b/src/share/vm/gc_implementation/parallelScavenge/generationSizer.cpp	Wed Jul 02 20:20:45 2014 -0400
@@ -66,10 +66,9 @@
 
 void GenerationSizer::initialize_size_info() {
   trace_gen_sizes("ps heap raw");
-  const size_t max_page_sz = os::page_size_for_region(_max_heap_byte_size, 8);
-  const size_t min_pages = 4; // 1 for eden + 1 for each survivor + 1 for old
-  const size_t min_page_sz = os::page_size_for_region(_min_heap_byte_size, min_pages);
-  const size_t page_sz = MIN2(max_page_sz, min_page_sz);
+  const size_t page_sz = os::page_size_for_region(_min_heap_byte_size,
+                                                  _max_heap_byte_size,
+                                                  8);
 
   // Can a page size be something else than a power of two?
   assert(is_power_of_2((intptr_t)page_sz), "must be a power of 2");
--- a/src/share/vm/gc_implementation/parallelScavenge/parMarkBitMap.cpp	Thu Jun 26 16:05:15 2014 +0200
+++ b/src/share/vm/gc_implementation/parallelScavenge/parMarkBitMap.cpp	Wed Jul 02 20:20:45 2014 -0400
@@ -41,7 +41,7 @@
 
   const size_t words = bits / BitsPerWord;
   const size_t raw_bytes = words * sizeof(idx_t);
-  const size_t page_sz = os::page_size_for_region(raw_bytes, 10);
+  const size_t page_sz = os::page_size_for_region(raw_bytes, raw_bytes, 10);
   const size_t granularity = os::vm_allocation_granularity();
   _reserved_byte_size = align_size_up(raw_bytes, MAX2(page_sz, granularity));
 
--- a/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp	Thu Jun 26 16:05:15 2014 +0200
+++ b/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp	Wed Jul 02 20:20:45 2014 -0400
@@ -403,7 +403,7 @@
 ParallelCompactData::create_vspace(size_t count, size_t element_size)
 {
   const size_t raw_bytes = count * element_size;
-  const size_t page_sz = os::page_size_for_region(raw_bytes, 10);
+  const size_t page_sz = os::page_size_for_region(raw_bytes, raw_bytes, 10);
   const size_t granularity = os::vm_allocation_granularity();
   _reserved_byte_size = align_size_up(raw_bytes, MAX2(page_sz, granularity));
 
--- a/src/share/vm/memory/heap.cpp	Thu Jun 26 16:05:15 2014 +0200
+++ b/src/share/vm/memory/heap.cpp	Wed Jul 02 20:20:45 2014 -0400
@@ -98,13 +98,9 @@
   _log2_segment_size = exact_log2(segment_size);
 
   // Reserve and initialize space for _memory.
-  size_t page_size = os::vm_page_size();
-  if (os::can_execute_large_page_memory()) {
-    const size_t min_pages = 8;
-    page_size = MIN2(os::page_size_for_region(committed_size, min_pages),
-                     os::page_size_for_region(reserved_size, min_pages));
-  }
-
+  const size_t page_size = os::can_execute_large_page_memory() ?
+          os::page_size_for_region(committed_size, reserved_size, 8) :
+          os::vm_page_size();
   const size_t granularity = os::vm_allocation_granularity();
   const size_t r_align = MAX2(page_size, granularity);
   const size_t r_size = align_size_up(reserved_size, r_align);
--- a/src/share/vm/prims/jni.cpp	Thu Jun 26 16:05:15 2014 +0200
+++ b/src/share/vm/prims/jni.cpp	Wed Jul 02 20:20:45 2014 -0400
@@ -3853,7 +3853,6 @@
   unit_test_function_call
 
 // Forward declaration
-void TestOS_test();
 void TestReservedSpace_test();
 void TestReserveMemorySpecial_test();
 void TestVirtualSpace_test();
@@ -3875,7 +3874,6 @@
 void execute_internal_vm_tests() {
   if (ExecuteInternalVMTests) {
     tty->print_cr("Running internal VM tests");
-    run_unit_test(TestOS_test());
     run_unit_test(TestReservedSpace_test());
     run_unit_test(TestReserveMemorySpecial_test());
     run_unit_test(TestVirtualSpace_test());
--- a/src/share/vm/runtime/os.cpp	Thu Jun 26 16:05:15 2014 +0200
+++ b/src/share/vm/runtime/os.cpp	Wed Jul 02 20:20:45 2014 -0400
@@ -1291,15 +1291,24 @@
   return (sp > (stack_limit + reserved_area));
 }
 
-size_t os::page_size_for_region(size_t region_size, size_t min_pages) {
+size_t os::page_size_for_region(size_t region_min_size, size_t region_max_size,
+                                uint min_pages)
+{
   assert(min_pages > 0, "sanity");
   if (UseLargePages) {
-    const size_t max_page_size = region_size / min_pages;
+    const size_t max_page_size = region_max_size / min_pages;
 
-    for (size_t i = 0; _page_sizes[i] != 0; ++i) {
-      const size_t page_size = _page_sizes[i];
-      if (page_size <= max_page_size && is_size_aligned(region_size, page_size)) {
-        return page_size;
+    for (unsigned int i = 0; _page_sizes[i] != 0; ++i) {
+      const size_t sz = _page_sizes[i];
+      const size_t mask = sz - 1;
+      if ((region_min_size & mask) == 0 && (region_max_size & mask) == 0) {
+        // The largest page size with no fragmentation.
+        return sz;
+      }
+
+      if (sz <= max_page_size) {
+        // The largest page size that satisfies the min_pages requirement.
+        return sz;
       }
     }
   }
@@ -1527,63 +1536,3 @@
   return result;
 }
 #endif
-
-/////////////// Unit tests ///////////////
-
-#ifndef PRODUCT
-
-#define assert_eq(a,b) assert(a == b, err_msg(SIZE_FORMAT " != " SIZE_FORMAT, a, b))
-
-class TestOS : AllStatic {
-  static size_t small_page_size() {
-    return os::vm_page_size();
-  }
-
-  static size_t large_page_size() {
-    const size_t large_page_size_example = 4 * M;
-    return os::page_size_for_region(large_page_size_example, 1);
-  }
-
-  static void test_page_size_for_region() {
-    if (UseLargePages) {
-      const size_t small_page = small_page_size();
-      const size_t large_page = large_page_size();
-
-      if (large_page > small_page) {
-        size_t num_small_pages_in_large = large_page / small_page;
-        size_t page = os::page_size_for_region(large_page, num_small_pages_in_large);
-
-        assert_eq(page, small_page);
-      }
-    }
-  }
-
-  static void test_page_size_for_region_alignment() {
-    if (UseLargePages) {
-      const size_t small_page = small_page_size();
-      const size_t large_page = large_page_size();
-      if (large_page > small_page) {
-        const size_t unaligned_region = large_page + 17;
-        size_t page = os::page_size_for_region(unaligned_region, 1);
-        assert_eq(page, small_page);
-
-        const size_t num_pages = 5;
-        const size_t aligned_region = large_page * num_pages;
-        page = os::page_size_for_region(aligned_region, num_pages);
-        assert_eq(page, large_page);
-      }
-    }
-  }
-
- public:
-  static void run_tests() {
-    test_page_size_for_region();
-    test_page_size_for_region_alignment();
-  }
-};
-
-void TestOS_test() {
-  TestOS::run_tests();
-}
-
-#endif // PRODUCT
--- a/src/share/vm/runtime/os.hpp	Thu Jun 26 16:05:15 2014 +0200
+++ b/src/share/vm/runtime/os.hpp	Wed Jul 02 20:20:45 2014 -0400
@@ -253,11 +253,19 @@
   // Return the default page size.
   static int    vm_page_size();
 
-  // Returns the page size to use for a region of memory.
-  // region_size / min_pages will always be greater than or equal to the
-  // returned value.
-  static size_t page_size_for_region(size_t region_size, size_t min_pages);
-
+  // Return the page size to use for a region of memory.  The min_pages argument
+  // is a hint intended to limit fragmentation; it says the returned page size
+  // should be <= region_max_size / min_pages.  Because min_pages is a hint,
+  // this routine may return a size larger than region_max_size / min_pages.
+  //
+  // The current implementation ignores min_pages if a larger page size is an
+  // exact multiple of both region_min_size and region_max_size.  This allows
+  // larger pages to be used when doing so would not cause fragmentation; in
+  // particular, a single page can be used when region_min_size ==
+  // region_max_size == a supported page size.
+  static size_t page_size_for_region(size_t region_min_size,
+                                     size_t region_max_size,
+                                     uint min_pages);
   // Return the largest page size that can be used
   static size_t max_page_size() {
     // The _page_sizes array is sorted in descending order.
--- a/src/share/vm/runtime/virtualspace.cpp	Thu Jun 26 16:05:15 2014 +0200
+++ b/src/share/vm/runtime/virtualspace.cpp	Wed Jul 02 20:20:45 2014 -0400
@@ -38,7 +38,7 @@
 }
 
 ReservedSpace::ReservedSpace(size_t size) {
-  size_t page_size = os::page_size_for_region(size, 1);
+  size_t page_size = os::page_size_for_region(size, size, 1);
   bool large_pages = page_size != (size_t)os::vm_page_size();
   // Don't force the alignment to be large page aligned,
   // since that will waste memory.
@@ -357,7 +357,7 @@
 
 
 bool VirtualSpace::initialize(ReservedSpace rs, size_t committed_size) {
-  const size_t max_commit_granularity = os::page_size_for_region(rs.size(), 1);
+  const size_t max_commit_granularity = os::page_size_for_region(rs.size(), rs.size(), 1);
   return initialize_with_granularity(rs, committed_size, max_commit_granularity);
 }
 
@@ -992,7 +992,7 @@
     case Disable:
       return vs.initialize_with_granularity(rs, 0, os::vm_page_size());
     case Commit:
-      return vs.initialize_with_granularity(rs, 0, os::page_size_for_region(rs.size(), 1));
+      return vs.initialize_with_granularity(rs, 0, os::page_size_for_region(rs.size(), rs.size(), 1));
     }
   }
 
--- a/test/gc/arguments/TestParallelHeapSizeFlags.java	Thu Jun 26 16:05:15 2014 +0200
+++ b/test/gc/arguments/TestParallelHeapSizeFlags.java	Wed Jul 02 20:20:45 2014 -0400
@@ -22,6 +22,7 @@
 */
 
 /*
+ * @ignore 8027915
  * @test TestParallelHeapSizeFlags
  * @key gc
  * @bug 8006088