jdk-sandbox: comparison hotspot/src/share/vm/memory/metaspace.cpp

equal deleted inserted replaced

-:3ad47a56094a
+:fa5f7a2bf717
 #include "services/memoryService.hpp"
 #include "utilities/copy.hpp"
 #include "utilities/debug.hpp"
 #include "utilities/macros.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
 typedef BinaryTreeDictionary<Metablock, FreeList<Metablock> > BlockTreeDictionary;
 typedef BinaryTreeDictionary<Metachunk, FreeList<Metachunk> > ChunkTreeDictionary;
 // Set this constant to enable slow integrity checking of the free chunk lists
 const bool metaspace_slow_verify = false;
 };
 #define assert_is_ptr_aligned(ptr, alignment) \
 assert(is_ptr_aligned(ptr, alignment),      \
 err_msg(PTR_FORMAT " is not aligned to "  \
-SIZE_FORMAT, ptr, alignment))
+SIZE_FORMAT, p2i(ptr), alignment))
 #define assert_is_size_aligned(size, alignment) \
 assert(is_size_aligned(size, alignment),      \
 err_msg(SIZE_FORMAT " is not aligned to "   \
 SIZE_FORMAT, size, alignment))
 void VirtualSpaceNode::inc_container_count() {
 assert_lock_strong(SpaceManager::expand_lock());
 _container_count++;
 assert(_container_count == container_count_slow(),
 err_msg("Inconsistency in container_count _container_count " SIZE_FORMAT
-" container_count_slow() " SIZE_FORMAT,
+" container_count_slow() %u",
 _container_count, container_count_slow()));
 }
 void VirtualSpaceNode::dec_container_count() {
 assert_lock_strong(SpaceManager::expand_lock());
 #ifdef ASSERT
 void VirtualSpaceNode::verify_container_count() {
 assert(_container_count == container_count_slow(),
 err_msg("Inconsistency in container_count _container_count " SIZE_FORMAT
-" container_count_slow() " SIZE_FORMAT, _container_count, container_count_slow()));
+" container_count_slow() %u", _container_count, container_count_slow()));
 }
 #endif
 // BlockFreelist methods
 assert(_virtual_space.committed_size() == _virtual_space.actual_committed_size(),
 "The committed memory doesn't match the expanded memory.");
 if (!is_available(chunk_word_size)) {
 if (TraceMetadataChunkAllocation) {
-gclog_or_tty->print("VirtualSpaceNode::take_from_committed() not available %d words ", chunk_word_size);
+gclog_or_tty->print("VirtualSpaceNode::take_from_committed() not available " SIZE_FORMAT " words ", chunk_word_size);
 // Dump some information about the virtual space that is nearly full
 print_on(gclog_or_tty);
 }
 return NULL;
 }
 set_reserved(MemRegion((HeapWord*)_rs.base(),
 (HeapWord*)(_rs.base() + _rs.size())));
 assert(reserved()->start() == (HeapWord*) _rs.base(),
 err_msg("Reserved start was not set properly " PTR_FORMAT
-" != " PTR_FORMAT, reserved()->start(), _rs.base()));
+" != " PTR_FORMAT, p2i(reserved()->start()), p2i(_rs.base())));
 assert(reserved()->word_size() == _rs.size() / BytesPerWord,
 err_msg("Reserved size was not set properly " SIZE_FORMAT
 " != " SIZE_FORMAT, reserved()->word_size(),
 _rs.size() / BytesPerWord));
 }
 void VirtualSpaceNode::print_on(outputStream* st) const {
 size_t used = used_words_in_vs();
 size_t capacity = capacity_words_in_vs();
 VirtualSpace* vs = virtual_space();
-st->print_cr("   space @ " PTR_FORMAT " " SIZE_FORMAT "K, %3d%% used "
+st->print_cr("   space @ " PTR_FORMAT " " SIZE_FORMAT "K, " SIZE_FORMAT_W(3) "%% used "
 "[" PTR_FORMAT ", " PTR_FORMAT ", "
 PTR_FORMAT ", " PTR_FORMAT ")",
-vs, capacity / K,
+p2i(vs), capacity / K,
 capacity == 0 ? 0 : used * 100 / capacity,
-bottom(), top(), end(),
+p2i(bottom()), p2i(top()), p2i(end()),
-vs->high_boundary());
+p2i(vs->high_boundary()));
 }
 #ifdef ASSERT
 void VirtualSpaceNode::mangle() {
 size_t word_size = capacity_words_in_vs();
 free_list->remove_chunk(chunk);
 if (TraceMetadataChunkAllocation && Verbose) {
 gclog_or_tty->print_cr("ChunkManager::free_chunks_get: free_list "
 PTR_FORMAT " head " PTR_FORMAT " size " SIZE_FORMAT,
-free_list, chunk, chunk->word_size());
+p2i(free_list), p2i(chunk), chunk->word_size());
 }
 } else {
 chunk = humongous_dictionary()->get_chunk(
 word_size,
 FreeBlockDictionary<Metachunk>::atLeast);
 } else {
 list_count = humongous_dictionary()->total_count();
 }
 gclog_or_tty->print("ChunkManager::chunk_freelist_allocate: " PTR_FORMAT " chunk "
 PTR_FORMAT "  size " SIZE_FORMAT " count " SIZE_FORMAT " ",
-this, chunk, chunk->word_size(), list_count);
+p2i(this), p2i(chunk), chunk->word_size(), list_count);
 locked_print_free_chunks(gclog_or_tty);
 }
 return chunk;
 }
 void SpaceManager::locked_print_chunks_in_use_on(outputStream* st) const {
 for (ChunkIndex i = ZeroIndex; i < NumberOfInUseLists; i = next_chunk_index(i)) {
 Metachunk* chunk = chunks_in_use(i);
 st->print("SpaceManager: %s " PTR_FORMAT,
-chunk_size_name(i), chunk);
+chunk_size_name(i), p2i(chunk));
 if (chunk != NULL) {
 st->print_cr(" free " SIZE_FORMAT,
 chunk->free_word_size());
 } else {
 st->cr();
 void SpaceManager::print_on(outputStream* st) const {
 for (ChunkIndex i = ZeroIndex;
 i < NumberOfInUseLists ;
 i = next_chunk_index(i) ) {
-st->print_cr("  chunks_in_use " PTR_FORMAT " chunk size " PTR_FORMAT,
+st->print_cr("  chunks_in_use " PTR_FORMAT " chunk size " SIZE_FORMAT,
-chunks_in_use(i),
+p2i(chunks_in_use(i)),
 chunks_in_use(i) == NULL ? 0 : chunks_in_use(i)->word_size());
 }
 st->print_cr("    waste:  Small " SIZE_FORMAT " Medium " SIZE_FORMAT
 " Humongous " SIZE_FORMAT,
 sum_waste_in_chunks_in_use(SmallIndex),
 for (ChunkIndex i = ZeroIndex; i < NumberOfInUseLists; i = next_chunk_index(i)) {
 _chunks_in_use[i] = NULL;
 }
 _current_chunk = NULL;
 if (TraceMetadataChunkAllocation && Verbose) {
-gclog_or_tty->print_cr("SpaceManager(): " PTR_FORMAT, this);
+gclog_or_tty->print_cr("SpaceManager(): " PTR_FORMAT, p2i(this));
 }
 }
 void ChunkManager::return_chunks(ChunkIndex index, Metachunk* chunks) {
 if (chunks == NULL) {
 chunk_manager()->slow_locked_verify();
 dec_total_from_size_metrics();
 if (TraceMetadataChunkAllocation && Verbose) {
-gclog_or_tty->print_cr("~SpaceManager(): " PTR_FORMAT, this);
+gclog_or_tty->print_cr("~SpaceManager(): " PTR_FORMAT, p2i(this));
 locked_print_chunks_in_use_on(gclog_or_tty);
 }
 // Do not mangle freed Metachunks.  The chunk size inside Metachunks
 // is during the freeing of a VirtualSpaceNodes.
 // Follow each list of chunks-in-use and add them to the
 // free lists.  Each list is NULL terminated.
 for (ChunkIndex i = ZeroIndex; i < HumongousIndex; i = next_chunk_index(i)) {
 if (TraceMetadataChunkAllocation && Verbose) {
-gclog_or_tty->print_cr("returned %d %s chunks to freelist",
+gclog_or_tty->print_cr("returned " SIZE_FORMAT " %s chunks to freelist",
 sum_count_in_chunks_in_use(i),
 chunk_size_name(i));
 }
 Metachunk* chunks = chunks_in_use(i);
 chunk_manager()->return_chunks(i, chunks);
 set_chunks_in_use(i, NULL);
 if (TraceMetadataChunkAllocation && Verbose) {
-gclog_or_tty->print_cr("updated freelist count %d %s",
+gclog_or_tty->print_cr("updated freelist count " SSIZE_FORMAT " %s",
 chunk_manager()->free_chunks(i)->count(),
 chunk_size_name(i));
 }
 assert(i != HumongousIndex, "Humongous chunks are handled explicitly later");
 }
 // tail of the medium chunk list to add_at_head().  The tail is often
 // the current chunk but there are probably exceptions.
 // Humongous chunks
 if (TraceMetadataChunkAllocation && Verbose) {
-gclog_or_tty->print_cr("returned %d %s humongous chunks to dictionary",
+gclog_or_tty->print_cr("returned " SIZE_FORMAT " %s humongous chunks to dictionary",
 sum_count_in_chunks_in_use(HumongousIndex),
 chunk_size_name(HumongousIndex));
 gclog_or_tty->print("Humongous chunk dictionary: ");
 }
 // Humongous chunks are never the current chunk.
 #ifdef ASSERT
 humongous_chunks->set_is_tagged_free(true);
 #endif
 if (TraceMetadataChunkAllocation && Verbose) {
 gclog_or_tty->print(PTR_FORMAT " (" SIZE_FORMAT ") ",
-humongous_chunks,
+p2i(humongous_chunks),
 humongous_chunks->word_size());
 }
 assert(humongous_chunks->word_size() == (size_t)
 align_size_up(humongous_chunks->word_size(),
 smallest_chunk_size()),
 err_msg("Humongous chunk size is wrong: word size " SIZE_FORMAT
-" granularity %d",
+" granularity " SIZE_FORMAT,
 humongous_chunks->word_size(), smallest_chunk_size()));
 Metachunk* next_humongous_chunks = humongous_chunks->next();
 humongous_chunks->container()->dec_container_count();
 chunk_manager()->humongous_dictionary()->return_chunk(humongous_chunks);
 humongous_chunks = next_humongous_chunks;
 }
 if (TraceMetadataChunkAllocation && Verbose) {
 gclog_or_tty->cr();
-gclog_or_tty->print_cr("updated dictionary count %d %s",
+gclog_or_tty->print_cr("updated dictionary count " SIZE_FORMAT " %s",
 chunk_manager()->humongous_dictionary()->total_count(),
 chunk_size_name(HumongousIndex));
 }
 chunk_manager()->slow_locked_verify();
 }
 // Add to the running sum of capacity
 inc_size_metrics(new_chunk->word_size());
 assert(new_chunk->is_empty(), "Not ready for reuse");
 if (TraceMetadataChunkAllocation && Verbose) {
-gclog_or_tty->print("SpaceManager::add_chunk: %d) ",
+gclog_or_tty->print("SpaceManager::add_chunk: " SIZE_FORMAT ") ",
 sum_count_in_chunks_in_use());
 new_chunk->print_on(gclog_or_tty);
 chunk_manager()->locked_print_free_chunks(gclog_or_tty);
 }
 }
 // So, UseCompressedClassPointers cannot be turned off at this point.
 if (!metaspace_rs.is_reserved()) {
 metaspace_rs = ReservedSpace(compressed_class_space_size(),
 _reserve_alignment, large_pages);
 if (!metaspace_rs.is_reserved()) {
-vm_exit_during_initialization(err_msg("Could not allocate metaspace: %d bytes",
+vm_exit_during_initialization(err_msg("Could not allocate metaspace: " SIZE_FORMAT " bytes",
 compressed_class_space_size()));
 }
 }
 }
 UseSharedSpaces ? (address)cds_base : 0);
 initialize_class_space(metaspace_rs);
 if (PrintCompressedOopsMode || (PrintMiscellaneous && Verbose)) {
-gclog_or_tty->print_cr("Narrow klass base: " PTR_FORMAT ", Narrow klass shift: " SIZE_FORMAT,
+gclog_or_tty->print_cr("Narrow klass base: " PTR_FORMAT ", Narrow klass shift: %d",
-Universe::narrow_klass_base(), Universe::narrow_klass_shift());
+p2i(Universe::narrow_klass_base()), Universe::narrow_klass_shift());
 gclog_or_tty->print_cr("Compressed class space size: " SIZE_FORMAT " Address: " PTR_FORMAT " Req Addr: " PTR_FORMAT,
-compressed_class_space_size(), metaspace_rs.base(), requested_addr);
+compressed_class_space_size(), p2i(metaspace_rs.base()), p2i(requested_addr));
 }
 }
 // For UseCompressedClassPointers the class space is reserved above the top of
 // the Java heap.  The argument passed in is at the base of the compressed space.
 #ifdef _LP64
 if (cds_total + compressed_class_space_size() > UnscaledClassSpaceMax) {
 vm_exit_during_initialization("Unable to dump shared archive.",
 err_msg("Size of archive (" SIZE_FORMAT ") + compressed class space ("
 SIZE_FORMAT ") == total (" SIZE_FORMAT ") is larger than compressed "
-"klass limit: " SIZE_FORMAT, cds_total, compressed_class_space_size(),
+"klass limit: " UINT64_FORMAT, cds_total, compressed_class_space_size(),
 cds_total + compressed_class_space_size(), UnscaledClassSpaceMax));
 }
 // Set the compressed klass pointer base so that decoding of these pointers works
 // properly when creating the shared archive.
 assert(UseCompressedOops && UseCompressedClassPointers,
 "UseCompressedOops and UseCompressedClassPointers must be set");
 Universe::set_narrow_klass_base((address)_space_list->current_virtual_space()->bottom());
 if (TraceMetavirtualspaceAllocation && Verbose) {
 gclog_or_tty->print_cr("Setting_narrow_klass_base to Address: " PTR_FORMAT,
-_space_list->current_virtual_space()->bottom());
+p2i(_space_list->current_virtual_space()->bottom()));
 }
 Universe::set_narrow_klass_shift(0);
 #endif // _LP64
 #endif // INCLUDE_CDS
 class_vsm()->verify();
 }
 }
 void Metaspace::dump(outputStream* const out) const {
-out->print_cr("\nVirtual space manager: " INTPTR_FORMAT, vsm());
+out->print_cr("\nVirtual space manager: " INTPTR_FORMAT, p2i(vsm()));
 vsm()->dump(out);
 if (using_class_space()) {
-out->print_cr("\nClass space manager: " INTPTR_FORMAT, class_vsm());
+out->print_cr("\nClass space manager: " INTPTR_FORMAT, p2i(class_vsm()));
 class_vsm()->dump(out);
 }
 }
 /////////////// Unit tests ///////////////
 #define assert_is_available_positive(word_size) \
 assert(vsn.is_available(word_size), \
 err_msg(#word_size ": " PTR_FORMAT " bytes were not available in " \
 "VirtualSpaceNode [" PTR_FORMAT ", " PTR_FORMAT ")", \
-(uintptr_t)(word_size * BytesPerWord), vsn.bottom(), vsn.end()));
+(uintptr_t)(word_size * BytesPerWord), p2i(vsn.bottom()), p2i(vsn.end())));
 #define assert_is_available_negative(word_size) \
 assert(!vsn.is_available(word_size), \
 err_msg(#word_size ": " PTR_FORMAT " bytes should not be available in " \
 "VirtualSpaceNode [" PTR_FORMAT ", " PTR_FORMAT ")", \
-(uintptr_t)(word_size * BytesPerWord), vsn.bottom(), vsn.end()));
+(uintptr_t)(word_size * BytesPerWord), p2i(vsn.bottom()), p2i(vsn.end())));
 static void test_is_available_positive() {
 // Reserve some memory.
 VirtualSpaceNode vsn(os::vm_allocation_granularity());
 assert(vsn.initialize(), "Failed to setup VirtualSpaceNode");

changeset 29800	fa5f7a2bf717
parent 29697	92501504191b
child 29806	64aa40385bdd