truffle: src/share/vm/memory/universe.cpp comparison

comparison src/share/vm/memory/universe.cpp @ 8506:c3657d00e343

-Merge with tip

author	Christos Kotselidis <christos.kotselidis@oracle.com>
date	Thu, 21 Mar 2013 14:11:13 +0100
parents	41fc46da946a 3c9bc17b9403
children	b9a918201d47

comparison

equal deleted inserted replaced

-:dee7c8b578c7
+:c3657d00e343
 #include "services/memoryService.hpp"
 #include "utilities/copy.hpp"
 #include "utilities/events.hpp"
 #include "utilities/hashtable.inline.hpp"
 #include "utilities/preserveException.hpp"
-#ifndef SERIALGC
+#include "utilities/macros.hpp"
+#if INCLUDE_ALL_GCS
 #include "gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp"
 #include "gc_implementation/concurrentMarkSweep/cmsCollectorPolicy.hpp"
 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
 #include "gc_implementation/g1/g1CollectorPolicy.hpp"
 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"
-#endif
+#endif // INCLUDE_ALL_GCS
 // Known objects
 Klass* Universe::_boolArrayKlassObj                 = NULL;
 Klass* Universe::_byteArrayKlassObj                 = NULL;
 Klass* Universe::_charArrayKlassObj                 = NULL;
 NarrowPtrStruct Universe::_narrow_oop = { NULL, 0, true };
 NarrowPtrStruct Universe::_narrow_klass = { NULL, 0, true };
 address Universe::_narrow_ptrs_base;
+size_t          Universe::_class_metaspace_size;
 void Universe::basic_type_classes_do(void f(Klass*)) {
 f(boolArrayKlassObj());
 f(byteArrayKlassObj());
 f(charArrayKlassObj());
 mode == HeapBasedNarrowOop, "mode is invalid");
 const size_t total_size = heap_size + HeapBaseMinAddress;
 // Return specified base for the first request.
 if (!FLAG_IS_DEFAULT(HeapBaseMinAddress) && (mode == UnscaledNarrowOop)) {
 base = HeapBaseMinAddress;
-} else if (total_size <= OopEncodingHeapMax && (mode != HeapBasedNarrowOop)) {
-if (total_size <= NarrowOopHeapMax && (mode == UnscaledNarrowOop) &&
+// If the total size and the metaspace size are small enough to allow
+// UnscaledNarrowOop then just use UnscaledNarrowOop.
+} else if ((total_size <= OopEncodingHeapMax) && (mode != HeapBasedNarrowOop) &&
+(!UseCompressedKlassPointers ||
+(((OopEncodingHeapMax - heap_size) + Universe::class_metaspace_size()) <= KlassEncodingMetaspaceMax))) {
+// We don't need to check the metaspace size here because it is always smaller
+// than total_size.
+if ((total_size <= NarrowOopHeapMax) && (mode == UnscaledNarrowOop) &&
 (Universe::narrow_oop_shift() == 0)) {
 // Use 32-bits oops without encoding and
 // place heap's top on the 4Gb boundary
 base = (NarrowOopHeapMax - heap_size);
 } else {
 // place heap's top on the 32Gb boundary in case
 // total_size > 4Gb or failed to reserve below 4Gb.
 base = (OopEncodingHeapMax - heap_size);
 }
 }
+// See if ZeroBaseNarrowOop encoding will work for a heap based at
+// (KlassEncodingMetaspaceMax - class_metaspace_size()).
+} else if (UseCompressedKlassPointers && (mode != HeapBasedNarrowOop) &&
+(Universe::class_metaspace_size() + HeapBaseMinAddress <= KlassEncodingMetaspaceMax) &&
+(KlassEncodingMetaspaceMax + heap_size - Universe::class_metaspace_size() <= OopEncodingHeapMax)) {
+base = (KlassEncodingMetaspaceMax - Universe::class_metaspace_size());
 } else {
-// Can't reserve below 32Gb.
+// UnscaledNarrowOop encoding didn't work, and no base was found for ZeroBasedOops or
+// HeapBasedNarrowOop encoding was requested.  So, can't reserve below 32Gb.
 Universe::set_narrow_oop_shift(LogMinObjAlignmentInBytes);
 }
 // Set narrow_oop_base and narrow_oop_use_implicit_null_checks
 // used in ReservedHeapSpace() constructors.
 // The final values will be set in initialize_heap() below.
-if (base != 0 && (base + heap_size) <= OopEncodingHeapMax) {
+if ((base != 0) && ((base + heap_size) <= OopEncodingHeapMax) &&
+(!UseCompressedKlassPointers || (base + Universe::class_metaspace_size()) <= KlassEncodingMetaspaceMax)) {
 // Use zero based compressed oops
 Universe::set_narrow_oop_base(NULL);
 // Don't need guard page for implicit checks in indexed
 // addressing mode with zero based Compressed Oops.
 Universe::set_narrow_oop_use_implicit_null_checks(true);
 }
 jint Universe::initialize_heap() {
 if (UseParallelGC) {
-#ifndef SERIALGC
+#if INCLUDE_ALL_GCS
 Universe::_collectedHeap = new ParallelScavengeHeap();
-#else  // SERIALGC
+#else  // INCLUDE_ALL_GCS
 fatal("UseParallelGC not supported in this VM.");
-#endif // SERIALGC
+#endif // INCLUDE_ALL_GCS
 } else if (UseG1GC) {
-#ifndef SERIALGC
+#if INCLUDE_ALL_GCS
 G1CollectorPolicy* g1p = new G1CollectorPolicy();
 G1CollectedHeap* g1h = new G1CollectedHeap(g1p);
 Universe::_collectedHeap = g1h;
-#else  // SERIALGC
+#else  // INCLUDE_ALL_GCS
 fatal("UseG1GC not supported in java kernel vm.");
-#endif // SERIALGC
+#endif // INCLUDE_ALL_GCS
 } else {
 GenCollectorPolicy *gc_policy;
 if (UseSerialGC) {
 gc_policy = new MarkSweepPolicy();
 } else if (UseConcMarkSweepGC) {
-#ifndef SERIALGC
+#if INCLUDE_ALL_GCS
 if (UseAdaptiveSizePolicy) {
 gc_policy = new ASConcurrentMarkSweepPolicy();
 } else {
 gc_policy = new ConcurrentMarkSweepPolicy();
 }
-#else   // SERIALGC
+#else  // INCLUDE_ALL_GCS
 fatal("UseConcMarkSweepGC not supported in this VM.");
-#endif // SERIALGC
+#endif // INCLUDE_ALL_GCS
 } else { // default old generation
 gc_policy = new MarkSweepPolicy();
 }
 Universe::_collectedHeap = new GenCollectedHeap(gc_policy);
 if (verbose) {
 tty->cr();
 tty->print("heap address: " PTR_FORMAT ", size: " SIZE_FORMAT " MB",
 Universe::heap()->base(), Universe::heap()->reserved_region().byte_size()/M);
 }
-if ((uint64_t)Universe::heap()->reserved_region().end() > OopEncodingHeapMax) {
+if (((uint64_t)Universe::heap()->reserved_region().end() > OopEncodingHeapMax) ||
+(UseCompressedKlassPointers &&
+((uint64_t)Universe::heap()->base() + Universe::class_metaspace_size() > KlassEncodingMetaspaceMax))) {
 // Can't reserve heap below 32Gb.
 // keep the Universe::narrow_oop_base() set in Universe::reserve_heap()
 Universe::set_narrow_oop_shift(LogMinObjAlignmentInBytes);
 if (verbose) {
 tty->print(", Compressed Oops with base: "PTR_FORMAT, Universe::narrow_oop_base());
 ReservedSpace Universe::reserve_heap(size_t heap_size, size_t alignment) {
 // Add in the class metaspace area so the classes in the headers can
 // be compressed the same as instances.
 // Need to round class space size up because it's below the heap and
 // the actual alignment depends on its size.
-size_t metaspace_size = align_size_up(ClassMetaspaceSize, alignment);
+Universe::set_class_metaspace_size(align_size_up(ClassMetaspaceSize, alignment));
-size_t total_reserved = align_size_up(heap_size + metaspace_size, alignment);
+size_t total_reserved = align_size_up(heap_size + Universe::class_metaspace_size(), alignment);
 char* addr = Universe::preferred_heap_base(total_reserved, Universe::UnscaledNarrowOop);
 ReservedHeapSpace total_rs(total_reserved, alignment, UseLargePages, addr);
 if (UseCompressedOops) {
 // as compressed oops. If compress oops and compress klass ptrs are
 // used we need the meta space first: if the alignment used for
 // compressed oops is greater than the one used for compressed klass
 // ptrs, a metadata space on top of the heap could become
 // unreachable.
-ReservedSpace class_rs = total_rs.first_part(metaspace_size);
+ReservedSpace class_rs = total_rs.first_part(Universe::class_metaspace_size());
-ReservedSpace heap_rs = total_rs.last_part(metaspace_size, alignment);
+ReservedSpace heap_rs = total_rs.last_part(Universe::class_metaspace_size(), alignment);
 Metaspace::initialize_class_space(class_rs);
 if (UseCompressedOops) {
 // Universe::initialize_heap() will reset this to NULL if unscaled
 // or zero-based narrow oops are actually used.

Mercurial > hg > truffle

comparison src/share/vm/memory/universe.cpp @ 8506:c3657d00e343