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

equal deleted inserted replaced

-:a7c0f60a1294
+:294e48b4f704
 #define index_bounds_check(index)                                         \
 assert(index == SpecializedIndex ||                                     \
 index == SmallIndex ||                                           \
 index == MediumIndex ||                                          \
-index == HumongousIndex, err_msg("Bad index: %d", (int) index))
+index == HumongousIndex, "Bad index: %d", (int) index)
 size_t num_free_chunks(ChunkIndex index) const {
 index_bounds_check(index);
 if (index == HumongousIndex) {
 void print_on(outputStream* st) const;
 };
 #define assert_is_ptr_aligned(ptr, alignment) \
 assert(is_ptr_aligned(ptr, alignment),      \
-err_msg(PTR_FORMAT " is not aligned to "  \
+PTR_FORMAT " is not aligned to "     \
-SIZE_FORMAT, p2i(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 " is not aligned to "      \
-SIZE_FORMAT, size, alignment))
+SIZE_FORMAT, size, alignment)
 // Decide if large pages should be committed when the memory is reserved.
 static bool should_commit_large_pages_when_reserving(size_t bytes) {
 if (UseLargePages && UseLargePagesInMetaspace && !os::can_commit_large_page_memory()) {
 }
 #ifdef ASSERT
 void VirtualSpaceNode::verify_container_count() {
 assert(_container_count == container_count_slow(),
-err_msg("Inconsistency in container_count _container_count " UINTX_FORMAT
+"Inconsistency in container_count _container_count " UINTX_FORMAT
-" container_count_slow() " UINTX_FORMAT, _container_count, container_count_slow()));
+" container_count_slow() " UINTX_FORMAT, _container_count, container_count_slow());
 }
 #endif
 // BlockFreelist methods
 set_top((MetaWord*)virtual_space()->low());
 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
+"Reserved start was not set properly " PTR_FORMAT
-" != " PTR_FORMAT, p2i(reserved()->start()), p2i(_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
+"Reserved size was not set properly " SIZE_FORMAT
 " != " SIZE_FORMAT, reserved()->word_size(),
-_rs.size() / BytesPerWord));
+_rs.size() / BytesPerWord);
 }
 return result;
 }
 void VirtualSpaceList::dec_reserved_words(size_t v) {
 assert_lock_strong(SpaceManager::expand_lock());
 _reserved_words = _reserved_words - v;
 }
-#define assert_committed_below_limit()                             \
+#define assert_committed_below_limit()                        \
-assert(MetaspaceAux::committed_bytes() <= MaxMetaspaceSize,      \
+assert(MetaspaceAux::committed_bytes() <= MaxMetaspaceSize, \
-err_msg("Too much committed memory. Committed: " SIZE_FORMAT \
+"Too much committed memory. Committed: " SIZE_FORMAT \
 " limit (MaxMetaspaceSize): " SIZE_FORMAT,           \
-MetaspaceAux::committed_bytes(), MaxMetaspaceSize));
+MetaspaceAux::committed_bytes(), MaxMetaspaceSize);
 void VirtualSpaceList::inc_committed_words(size_t v) {
 assert_lock_strong(SpaceManager::expand_lock());
 _committed_words = _committed_words + v;
 size_t MetaspaceGC::allowed_expansion() {
 size_t committed_bytes = MetaspaceAux::committed_bytes();
 size_t capacity_until_gc = capacity_until_GC();
 assert(capacity_until_gc >= committed_bytes,
-err_msg("capacity_until_gc: " SIZE_FORMAT " < committed_bytes: " SIZE_FORMAT,
+"capacity_until_gc: " SIZE_FORMAT " < committed_bytes: " SIZE_FORMAT,
-capacity_until_gc, committed_bytes));
+capacity_until_gc, committed_bytes);
 size_t left_until_max  = MaxMetaspaceSize - committed_bytes;
 size_t left_until_GC = capacity_until_gc - committed_bytes;
 size_t left_to_commit = MIN2(left_until_GC, left_until_max);
 }
 // No expansion, now see if we want to shrink
 // We would never want to shrink more than this
 assert(capacity_until_GC >= minimum_desired_capacity,
-err_msg(SIZE_FORMAT " >= " SIZE_FORMAT,
+SIZE_FORMAT " >= " SIZE_FORMAT,
-capacity_until_GC, minimum_desired_capacity));
+capacity_until_GC, minimum_desired_capacity);
 size_t max_shrink_bytes = capacity_until_GC - minimum_desired_capacity;
 // Should shrinking be considered?
 if (MaxMetaspaceFreeRatio < 100) {
 const double maximum_free_percentage = MaxMetaspaceFreeRatio / 100.0;
 shrink_bytes = shrink_bytes / 100 * current_shrink_factor;
 shrink_bytes = align_size_down(shrink_bytes, Metaspace::commit_alignment());
 assert(shrink_bytes <= max_shrink_bytes,
-err_msg("invalid shrink size " SIZE_FORMAT " not <= " SIZE_FORMAT,
+"invalid shrink size " SIZE_FORMAT " not <= " SIZE_FORMAT,
-shrink_bytes, max_shrink_bytes));
+shrink_bytes, max_shrink_bytes);
 if (current_shrink_factor == 0) {
 _shrink_factor = 10;
 } else {
 _shrink_factor = MIN2(current_shrink_factor * 4, (uint) 100);
 }
 }
 void ChunkManager::locked_verify_free_chunks_total() {
 assert_lock_strong(SpaceManager::expand_lock());
 assert(sum_free_chunks() == _free_chunks_total,
-err_msg("_free_chunks_total " SIZE_FORMAT " is not the"
+"_free_chunks_total " SIZE_FORMAT " is not the"
 " same as sum " SIZE_FORMAT, _free_chunks_total,
-sum_free_chunks()));
+sum_free_chunks());
 }
 void ChunkManager::verify_free_chunks_total() {
 MutexLockerEx cl(SpaceManager::expand_lock(),
 Mutex::_no_safepoint_check_flag);
 }
 void ChunkManager::locked_verify_free_chunks_count() {
 assert_lock_strong(SpaceManager::expand_lock());
 assert(sum_free_chunks_count() == _free_chunks_count,
-err_msg("_free_chunks_count " SIZE_FORMAT " is not the"
+"_free_chunks_count " SIZE_FORMAT " is not the"
 " same as sum " SIZE_FORMAT, _free_chunks_count,
-sum_free_chunks_count()));
+sum_free_chunks_count());
 }
 void ChunkManager::verify_free_chunks_count() {
 #ifdef ASSERT
 MutexLockerEx cl(SpaceManager::expand_lock(),
 *chunk_word_size = SmallChunk;
 *class_chunk_word_size = ClassSmallChunk;
 break;
 }
 assert(*chunk_word_size != 0 && *class_chunk_word_size != 0,
-err_msg("Initial chunks sizes bad: data  " SIZE_FORMAT
+"Initial chunks sizes bad: data  " SIZE_FORMAT
 " class " SIZE_FORMAT,
-*chunk_word_size, *class_chunk_word_size));
+*chunk_word_size, *class_chunk_word_size);
 }
 size_t SpaceManager::sum_free_in_chunks_in_use() const {
 MutexLockerEx cl(lock(), Mutex::_no_safepoint_check_flag);
 size_t free = 0;
 chunk_word_size =
 MAX2((size_t) chunk_word_size, if_humongous_sized_chunk);
 assert(!SpaceManager::is_humongous(word_size) ||
 chunk_word_size == if_humongous_sized_chunk,
-err_msg("Size calculation is wrong, word_size " SIZE_FORMAT
+"Size calculation is wrong, word_size " SIZE_FORMAT
 " chunk_word_size " SIZE_FORMAT,
-word_size, chunk_word_size));
+word_size, chunk_word_size);
 if (TraceMetadataHumongousAllocation &&
 SpaceManager::is_humongous(word_size)) {
 gclog_or_tty->print_cr("Metadata humongous allocation:");
 gclog_or_tty->print_cr("  word_size " PTR_FORMAT, word_size);
 gclog_or_tty->print_cr("  chunk_word_size " PTR_FORMAT,
 }
 SpaceManager::~SpaceManager() {
 // This call this->_lock which can't be done while holding expand_lock()
 assert(sum_capacity_in_chunks_in_use() == allocated_chunks_words(),
-err_msg("sum_capacity_in_chunks_in_use() " SIZE_FORMAT
+"sum_capacity_in_chunks_in_use() " SIZE_FORMAT
 " allocated_chunks_words() " SIZE_FORMAT,
-sum_capacity_in_chunks_in_use(), allocated_chunks_words()));
+sum_capacity_in_chunks_in_use(), allocated_chunks_words());
 MutexLockerEx fcl(SpaceManager::expand_lock(),
 Mutex::_no_safepoint_check_flag);
 chunk_manager()->slow_locked_verify();
 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
+"Humongous chunk size is wrong: word size " SIZE_FORMAT
 " granularity " SIZE_FORMAT,
-humongous_chunks->word_size(), smallest_chunk_size()));
+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;
 }
 void SpaceManager::deallocate(MetaWord* p, size_t word_size) {
 assert_lock_strong(_lock);
 size_t raw_word_size = get_raw_word_size(word_size);
 size_t min_size = TreeChunk<Metablock, FreeList<Metablock> >::min_size();
 assert(raw_word_size >= min_size,
-err_msg("Should not deallocate dark matter " SIZE_FORMAT "<" SIZE_FORMAT, word_size, min_size));
+"Should not deallocate dark matter " SIZE_FORMAT "<" SIZE_FORMAT, word_size, min_size);
 block_freelists()->return_block(p, raw_word_size);
 }
 // Adds a chunk to the list of chunks in use.
 void SpaceManager::add_chunk(Metachunk* new_chunk, bool make_current) {
 void SpaceManager::verify_allocated_blocks_words() {
 // Verification is only guaranteed at a safepoint.
 assert(SafepointSynchronize::is_at_safepoint() || !Universe::is_fully_initialized(),
 "Verification can fail if the applications is running");
 assert(allocated_blocks_words() == sum_used_in_chunks_in_use(),
-err_msg("allocation total is not consistent " SIZE_FORMAT
+"allocation total is not consistent " SIZE_FORMAT
 " vs " SIZE_FORMAT,
-allocated_blocks_words(), sum_used_in_chunks_in_use()));
+allocated_blocks_words(), sum_used_in_chunks_in_use());
 }
 #endif
 void SpaceManager::dump(outputStream* const out) const {
 }
 void MetaspaceAux::dec_capacity(Metaspace::MetadataType mdtype, size_t words) {
 assert_lock_strong(SpaceManager::expand_lock());
 assert(words <= capacity_words(mdtype),
-err_msg("About to decrement below 0: words " SIZE_FORMAT
+"About to decrement below 0: words " SIZE_FORMAT
 " is greater than _capacity_words[%u] " SIZE_FORMAT,
-words, mdtype, capacity_words(mdtype)));
+words, mdtype, capacity_words(mdtype));
 _capacity_words[mdtype] -= words;
 }
 void MetaspaceAux::inc_capacity(Metaspace::MetadataType mdtype, size_t words) {
 assert_lock_strong(SpaceManager::expand_lock());
 _capacity_words[mdtype] += words;
 }
 void MetaspaceAux::dec_used(Metaspace::MetadataType mdtype, size_t words) {
 assert(words <= used_words(mdtype),
-err_msg("About to decrement below 0: words " SIZE_FORMAT
+"About to decrement below 0: words " SIZE_FORMAT
 " is greater than _used_words[%u] " SIZE_FORMAT,
-words, mdtype, used_words(mdtype)));
+words, mdtype, used_words(mdtype));
 // For CMS deallocation of the Metaspaces occurs during the
 // sweep which is a concurrent phase.  Protection by the expand_lock()
 // is not enough since allocation is on a per Metaspace basis
 // and protected by the Metaspace lock.
 jlong minus_words = (jlong) - (jlong) words;
 guarantee(false, "Should not call capacity_bytes_slow() in the PRODUCT");
 #endif
 size_t class_capacity = capacity_bytes_slow(Metaspace::ClassType);
 size_t non_class_capacity = capacity_bytes_slow(Metaspace::NonClassType);
 assert(capacity_bytes() == class_capacity + non_class_capacity,
-err_msg("bad accounting: capacity_bytes() " SIZE_FORMAT
+"bad accounting: capacity_bytes() " SIZE_FORMAT
 " class_capacity + non_class_capacity " SIZE_FORMAT
 " class_capacity " SIZE_FORMAT " non_class_capacity " SIZE_FORMAT,
 capacity_bytes(), class_capacity + non_class_capacity,
-class_capacity, non_class_capacity));
+class_capacity, non_class_capacity);
 return class_capacity + non_class_capacity;
 }
 size_t MetaspaceAux::reserved_bytes(Metaspace::MetadataType mdtype) {
 #ifdef ASSERT
 size_t running_sum_capacity_bytes = capacity_bytes();
 // For purposes of the running sum of capacity, verify against capacity
 size_t capacity_in_use_bytes = capacity_bytes_slow();
 assert(running_sum_capacity_bytes == capacity_in_use_bytes,
-err_msg("capacity_words() * BytesPerWord " SIZE_FORMAT
+"capacity_words() * BytesPerWord " SIZE_FORMAT
 " capacity_bytes_slow()" SIZE_FORMAT,
-running_sum_capacity_bytes, capacity_in_use_bytes));
+running_sum_capacity_bytes, capacity_in_use_bytes);
 for (Metaspace::MetadataType i = Metaspace::ClassType;
 i < Metaspace:: MetadataTypeCount;
 i = (Metaspace::MetadataType)(i + 1)) {
 size_t capacity_in_use_bytes = capacity_bytes_slow(i);
 assert(capacity_bytes(i) == capacity_in_use_bytes,
-err_msg("capacity_bytes(%u) " SIZE_FORMAT
+"capacity_bytes(%u) " SIZE_FORMAT
 " capacity_bytes_slow(%u)" SIZE_FORMAT,
-i, capacity_bytes(i), i, capacity_in_use_bytes));
+i, capacity_bytes(i), i, capacity_in_use_bytes);
 }
 #endif
 }
 void MetaspaceAux::verify_used() {
 #ifdef ASSERT
 size_t running_sum_used_bytes = used_bytes();
 // For purposes of the running sum of used, verify against used
 size_t used_in_use_bytes = used_bytes_slow();
 assert(used_bytes() == used_in_use_bytes,
-err_msg("used_bytes() " SIZE_FORMAT
+"used_bytes() " SIZE_FORMAT
 " used_bytes_slow()" SIZE_FORMAT,
-used_bytes(), used_in_use_bytes));
+used_bytes(), used_in_use_bytes);
 for (Metaspace::MetadataType i = Metaspace::ClassType;
 i < Metaspace:: MetadataTypeCount;
 i = (Metaspace::MetadataType)(i + 1)) {
 size_t used_in_use_bytes = used_bytes_slow(i);
 assert(used_bytes(i) == used_in_use_bytes,
-err_msg("used_bytes(%u) " SIZE_FORMAT
+"used_bytes(%u) " SIZE_FORMAT
 " used_bytes_slow(%u)" SIZE_FORMAT,
-i, used_bytes(i), i, used_in_use_bytes));
+i, used_bytes(i), i, used_in_use_bytes);
 }
 #endif
 }
 void MetaspaceAux::verify_metrics() {
 // 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.
 void Metaspace::initialize_class_space(ReservedSpace rs) {
 // The reserved space size may be bigger because of alignment, esp with UseLargePages
 assert(rs.size() >= CompressedClassSpaceSize,
-err_msg(SIZE_FORMAT " != " SIZE_FORMAT, rs.size(), CompressedClassSpaceSize));
+SIZE_FORMAT " != " SIZE_FORMAT, rs.size(), CompressedClassSpaceSize);
 assert(using_class_space(), "Must be using class space");
 _class_space_list = new VirtualSpaceList(rs);
 _chunk_manager_class = new ChunkManager(SpecializedChunk, ClassSmallChunk, ClassMediumChunk);
 if (!_class_space_list->initialization_succeeded()) {
 const char* Metaspace::metadata_type_name(Metaspace::MetadataType mdtype) {
 switch (mdtype) {
 case Metaspace::ClassType: return "Class";
 case Metaspace::NonClassType: return "Metadata";
 default:
-assert(false, err_msg("Got bad mdtype: %d", (int) mdtype));
+assert(false, "Got bad mdtype: %d", (int) mdtype);
 return NULL;
 }
 }
 void Metaspace::record_allocation(void* ptr, MetaspaceObj::Type type, size_t word_size) {
 }
 #define assert_is_available_positive(word_size) \
 assert(vsn.is_available(word_size), \
-err_msg(#word_size ": " PTR_FORMAT " bytes were not available in " \
+#word_size ": " PTR_FORMAT " bytes were not available in " \
 "VirtualSpaceNode [" PTR_FORMAT ", " PTR_FORMAT ")", \
-(uintptr_t)(word_size * BytesPerWord), p2i(vsn.bottom()), p2i(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 " \
+#word_size ": " PTR_FORMAT " bytes should not be available in " \
 "VirtualSpaceNode [" PTR_FORMAT ", " PTR_FORMAT ")", \
-(uintptr_t)(word_size * BytesPerWord), p2i(vsn.bottom()), p2i(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 33105	294e48b4f704
parent 31374	9280d10f1f26
child 34242	e530decd7c63