1.1 --- a/src/share/vm/memory/metaspace.cpp Fri Nov 01 17:09:38 2013 +0100
1.2 +++ b/src/share/vm/memory/metaspace.cpp Sat Nov 02 13:02:59 2013 -0700
1.3 @@ -56,7 +56,7 @@
1.4
1.5 MetaWord* last_allocated = 0;
1.6
1.7 -size_t Metaspace::_class_metaspace_size;
1.8 +size_t Metaspace::_compressed_class_space_size;
1.9
1.10 // Used in declarations in SpaceManager and ChunkManager
1.11 enum ChunkIndex {
1.12 @@ -2843,6 +2843,8 @@
1.13 #define VIRTUALSPACEMULTIPLIER 2
1.14
1.15 #ifdef _LP64
1.16 +static const uint64_t UnscaledClassSpaceMax = (uint64_t(max_juint) + 1);
1.17 +
1.18 void Metaspace::set_narrow_klass_base_and_shift(address metaspace_base, address cds_base) {
1.19 // Figure out the narrow_klass_base and the narrow_klass_shift. The
1.20 // narrow_klass_base is the lower of the metaspace base and the cds base
1.21 @@ -2852,14 +2854,22 @@
1.22 address higher_address;
1.23 if (UseSharedSpaces) {
1.24 higher_address = MAX2((address)(cds_base + FileMapInfo::shared_spaces_size()),
1.25 - (address)(metaspace_base + class_metaspace_size()));
1.26 + (address)(metaspace_base + compressed_class_space_size()));
1.27 lower_base = MIN2(metaspace_base, cds_base);
1.28 } else {
1.29 - higher_address = metaspace_base + class_metaspace_size();
1.30 + higher_address = metaspace_base + compressed_class_space_size();
1.31 lower_base = metaspace_base;
1.32 +
1.33 + uint64_t klass_encoding_max = UnscaledClassSpaceMax << LogKlassAlignmentInBytes;
1.34 + // If compressed class space fits in lower 32G, we don't need a base.
1.35 + if (higher_address <= (address)klass_encoding_max) {
1.36 + lower_base = 0; // effectively lower base is zero.
1.37 + }
1.38 }
1.39 +
1.40 Universe::set_narrow_klass_base(lower_base);
1.41 - if ((uint64_t)(higher_address - lower_base) < (uint64_t)max_juint) {
1.42 +
1.43 + if ((uint64_t)(higher_address - lower_base) < UnscaledClassSpaceMax) {
1.44 Universe::set_narrow_klass_shift(0);
1.45 } else {
1.46 assert(!UseSharedSpaces, "Cannot shift with UseSharedSpaces");
1.47 @@ -2874,24 +2884,24 @@
1.48 assert(UseCompressedClassPointers, "Only use with CompressedKlassPtrs");
1.49 address lower_base = MIN2((address)metaspace_base, cds_base);
1.50 address higher_address = MAX2((address)(cds_base + FileMapInfo::shared_spaces_size()),
1.51 - (address)(metaspace_base + class_metaspace_size()));
1.52 - return ((uint64_t)(higher_address - lower_base) < (uint64_t)max_juint);
1.53 + (address)(metaspace_base + compressed_class_space_size()));
1.54 + return ((uint64_t)(higher_address - lower_base) < UnscaledClassSpaceMax);
1.55 }
1.56
1.57 // Try to allocate the metaspace at the requested addr.
1.58 void Metaspace::allocate_metaspace_compressed_klass_ptrs(char* requested_addr, address cds_base) {
1.59 assert(using_class_space(), "called improperly");
1.60 assert(UseCompressedClassPointers, "Only use with CompressedKlassPtrs");
1.61 - assert(class_metaspace_size() < KlassEncodingMetaspaceMax,
1.62 + assert(compressed_class_space_size() < KlassEncodingMetaspaceMax,
1.63 "Metaspace size is too big");
1.64 - assert_is_ptr_aligned(requested_addr, _reserve_alignment);
1.65 - assert_is_ptr_aligned(cds_base, _reserve_alignment);
1.66 - assert_is_size_aligned(class_metaspace_size(), _reserve_alignment);
1.67 + assert_is_ptr_aligned(requested_addr, _reserve_alignment);
1.68 + assert_is_ptr_aligned(cds_base, _reserve_alignment);
1.69 + assert_is_size_aligned(compressed_class_space_size(), _reserve_alignment);
1.70
1.71 // Don't use large pages for the class space.
1.72 bool large_pages = false;
1.73
1.74 - ReservedSpace metaspace_rs = ReservedSpace(class_metaspace_size(),
1.75 + ReservedSpace metaspace_rs = ReservedSpace(compressed_class_space_size(),
1.76 _reserve_alignment,
1.77 large_pages,
1.78 requested_addr, 0);
1.79 @@ -2906,7 +2916,7 @@
1.80 while (!metaspace_rs.is_reserved() && (addr + increment > addr) &&
1.81 can_use_cds_with_metaspace_addr(addr + increment, cds_base)) {
1.82 addr = addr + increment;
1.83 - metaspace_rs = ReservedSpace(class_metaspace_size(),
1.84 + metaspace_rs = ReservedSpace(compressed_class_space_size(),
1.85 _reserve_alignment, large_pages, addr, 0);
1.86 }
1.87 }
1.88 @@ -2917,11 +2927,11 @@
1.89 // initialization has happened that depends on UseCompressedClassPointers.
1.90 // So, UseCompressedClassPointers cannot be turned off at this point.
1.91 if (!metaspace_rs.is_reserved()) {
1.92 - metaspace_rs = ReservedSpace(class_metaspace_size(),
1.93 + metaspace_rs = ReservedSpace(compressed_class_space_size(),
1.94 _reserve_alignment, large_pages);
1.95 if (!metaspace_rs.is_reserved()) {
1.96 vm_exit_during_initialization(err_msg("Could not allocate metaspace: %d bytes",
1.97 - class_metaspace_size()));
1.98 + compressed_class_space_size()));
1.99 }
1.100 }
1.101 }
1.102 @@ -2943,8 +2953,8 @@
1.103 if (PrintCompressedOopsMode || (PrintMiscellaneous && Verbose)) {
1.104 gclog_or_tty->print_cr("Narrow klass base: " PTR_FORMAT ", Narrow klass shift: " SIZE_FORMAT,
1.105 Universe::narrow_klass_base(), Universe::narrow_klass_shift());
1.106 - gclog_or_tty->print_cr("Metaspace Size: " SIZE_FORMAT " Address: " PTR_FORMAT " Req Addr: " PTR_FORMAT,
1.107 - class_metaspace_size(), metaspace_rs.base(), requested_addr);
1.108 + gclog_or_tty->print_cr("Compressed class space size: " SIZE_FORMAT " Address: " PTR_FORMAT " Req Addr: " PTR_FORMAT,
1.109 + compressed_class_space_size(), metaspace_rs.base(), requested_addr);
1.110 }
1.111 }
1.112
1.113 @@ -3005,7 +3015,7 @@
1.114 MaxMetaspaceExpansion = align_size_down_bounded(MaxMetaspaceExpansion, _commit_alignment);
1.115
1.116 CompressedClassSpaceSize = align_size_down_bounded(CompressedClassSpaceSize, _reserve_alignment);
1.117 - set_class_metaspace_size(CompressedClassSpaceSize);
1.118 + set_compressed_class_space_size(CompressedClassSpaceSize);
1.119 }
1.120
1.121 void Metaspace::global_initialize() {
1.122 @@ -3034,12 +3044,12 @@
1.123 }
1.124
1.125 #ifdef _LP64
1.126 - if (cds_total + class_metaspace_size() > (uint64_t)max_juint) {
1.127 + if (cds_total + compressed_class_space_size() > UnscaledClassSpaceMax) {
1.128 vm_exit_during_initialization("Unable to dump shared archive.",
1.129 err_msg("Size of archive (" SIZE_FORMAT ") + compressed class space ("
1.130 SIZE_FORMAT ") == total (" SIZE_FORMAT ") is larger than compressed "
1.131 - "klass limit: " SIZE_FORMAT, cds_total, class_metaspace_size(),
1.132 - cds_total + class_metaspace_size(), (size_t)max_juint));
1.133 + "klass limit: " SIZE_FORMAT, cds_total, compressed_class_space_size(),
1.134 + cds_total + compressed_class_space_size(), UnscaledClassSpaceMax));
1.135 }
1.136
1.137 // Set the compressed klass pointer base so that decoding of these pointers works
1.138 @@ -3087,7 +3097,8 @@
1.139 cds_end = (char *)align_ptr_up(cds_end, _reserve_alignment);
1.140 allocate_metaspace_compressed_klass_ptrs(cds_end, cds_address);
1.141 } else {
1.142 - allocate_metaspace_compressed_klass_ptrs((char *)CompressedKlassPointersBase, 0);
1.143 + char* base = (char*)align_ptr_up(Universe::heap()->reserved_region().end(), _reserve_alignment);
1.144 + allocate_metaspace_compressed_klass_ptrs(base, 0);
1.145 }
1.146 }
1.147 #endif
1.148 @@ -3349,6 +3360,11 @@
1.149 return result;
1.150 }
1.151
1.152 +size_t Metaspace::class_chunk_size(size_t word_size) {
1.153 + assert(using_class_space(), "Has to use class space");
1.154 + return class_vsm()->calc_chunk_size(word_size);
1.155 +}
1.156 +
1.157 void Metaspace::report_metadata_oome(ClassLoaderData* loader_data, size_t word_size, MetadataType mdtype, TRAPS) {
1.158 // If result is still null, we are out of memory.
1.159 if (Verbose && TraceMetadataChunkAllocation) {
1.160 @@ -3360,9 +3376,19 @@
1.161 MetaspaceAux::dump(gclog_or_tty);
1.162 }
1.163
1.164 + bool out_of_compressed_class_space = false;
1.165 + if (is_class_space_allocation(mdtype)) {
1.166 + Metaspace* metaspace = loader_data->metaspace_non_null();
1.167 + out_of_compressed_class_space =
1.168 + MetaspaceAux::committed_bytes(Metaspace::ClassType) +
1.169 + (metaspace->class_chunk_size(word_size) * BytesPerWord) >
1.170 + CompressedClassSpaceSize;
1.171 + }
1.172 +
1.173 // -XX:+HeapDumpOnOutOfMemoryError and -XX:OnOutOfMemoryError support
1.174 - const char* space_string = is_class_space_allocation(mdtype) ? "Compressed class space" :
1.175 - "Metadata space";
1.176 + const char* space_string = out_of_compressed_class_space ?
1.177 + "Compressed class space" : "Metaspace";
1.178 +
1.179 report_java_out_of_memory(space_string);
1.180
1.181 if (JvmtiExport::should_post_resource_exhausted()) {
1.182 @@ -3375,7 +3401,7 @@
1.183 vm_exit_during_initialization("OutOfMemoryError", space_string);
1.184 }
1.185
1.186 - if (is_class_space_allocation(mdtype)) {
1.187 + if (out_of_compressed_class_space) {
1.188 THROW_OOP(Universe::out_of_memory_error_class_metaspace());
1.189 } else {
1.190 THROW_OOP(Universe::out_of_memory_error_metaspace());
