jdk-sandbox: comparison hotspot/src/share/vm/gc/g1/g1CollectedHeap.cpp

equal deleted inserted replaced

-:a7c0f60a1294
+:294e48b4f704
 size_t word_size = curr_range.word_size();
 HeapWord* last_address = curr_range.last();
 size_t commits = 0;
 guarantee(reserved.contains(start_address) && reserved.contains(last_address),
-err_msg("MemRegion outside of heap [" PTR_FORMAT ", " PTR_FORMAT "]",
+"MemRegion outside of heap [" PTR_FORMAT ", " PTR_FORMAT "]",
-p2i(start_address), p2i(last_address)));
+p2i(start_address), p2i(last_address));
 guarantee(start_address > prev_last_addr,
-err_msg("Ranges not in ascending order: " PTR_FORMAT " <= " PTR_FORMAT ,
+"Ranges not in ascending order: " PTR_FORMAT " <= " PTR_FORMAT ,
-p2i(start_address), p2i(prev_last_addr)));
+p2i(start_address), p2i(prev_last_addr));
 prev_last_addr = last_address;
 // Check for ranges that start in the same G1 region in which the previous
 // range ended, and adjust the start address so we don't try to allocate
 // the same region again. If the current range is entirely within that
 HeapRegion* last_region = _hrm.addr_to_region(last_address);
 prev_last_region = last_region;
 while (curr_region != NULL) {
 assert(curr_region->is_empty() && !curr_region->is_pinned(),
-err_msg("Region already in use (index %u)", curr_region->hrm_index()));
+"Region already in use (index %u)", curr_region->hrm_index());
 _hr_printer.alloc(curr_region, G1HRPrinter::Archive);
 curr_region->set_allocation_context(AllocationContext::system());
 curr_region->set_archive();
 _old_set.add(curr_region);
 if (curr_region != last_region) {
 for (size_t i = 0; i < count; i++) {
 HeapWord* start_address = ranges[i].start();
 HeapWord* last_address = ranges[i].last();
 assert(reserved.contains(start_address) && reserved.contains(last_address),
-err_msg("MemRegion outside of heap [" PTR_FORMAT ", " PTR_FORMAT "]",
+"MemRegion outside of heap [" PTR_FORMAT ", " PTR_FORMAT "]",
-p2i(start_address), p2i(last_address)));
+p2i(start_address), p2i(last_address));
 assert(start_address > prev_last_addr,
-err_msg("Ranges not in ascending order: " PTR_FORMAT " <= " PTR_FORMAT ,
+"Ranges not in ascending order: " PTR_FORMAT " <= " PTR_FORMAT ,
-p2i(start_address), p2i(prev_last_addr)));
+p2i(start_address), p2i(prev_last_addr));
 HeapRegion* start_region = _hrm.addr_to_region(start_address);
 HeapRegion* last_region = _hrm.addr_to_region(last_address);
 HeapWord* bottom_address = start_region->bottom();
 // Verify that the regions were all marked as archive regions by
 // alloc_archive_regions.
 HeapRegion* curr_region = start_region;
 while (curr_region != NULL) {
 guarantee(curr_region->is_archive(),
-err_msg("Expected archive region at index %u", curr_region->hrm_index()));
+"Expected archive region at index %u", curr_region->hrm_index());
 if (curr_region != last_region) {
 curr_region = _hrm.next_region_in_heap(curr_region);
 } else {
 curr_region = NULL;
 }
 for (size_t i = 0; i < count; i++) {
 HeapWord* start_address = ranges[i].start();
 HeapWord* last_address = ranges[i].last();
 assert(reserved.contains(start_address) && reserved.contains(last_address),
-err_msg("MemRegion outside of heap [" PTR_FORMAT ", " PTR_FORMAT "]",
+"MemRegion outside of heap [" PTR_FORMAT ", " PTR_FORMAT "]",
-p2i(start_address), p2i(last_address)));
+p2i(start_address), p2i(last_address));
 assert(start_address > prev_last_addr,
-err_msg("Ranges not in ascending order: " PTR_FORMAT " <= " PTR_FORMAT ,
+"Ranges not in ascending order: " PTR_FORMAT " <= " PTR_FORMAT ,
-p2i(start_address), p2i(prev_last_addr)));
+p2i(start_address), p2i(prev_last_addr));
 size_used += ranges[i].byte_size();
 prev_last_addr = last_address;
 HeapRegion* start_region = _hrm.addr_to_region(start_address);
 HeapRegion* last_region = _hrm.addr_to_region(last_address);
 // After verifying that each region was marked as an archive region by
 // alloc_archive_regions, set it free and empty and uncommit it.
 HeapRegion* curr_region = start_region;
 while (curr_region != NULL) {
 guarantee(curr_region->is_archive(),
-err_msg("Expected archive region at index %u", curr_region->hrm_index()));
+"Expected archive region at index %u", curr_region->hrm_index());
 uint curr_index = curr_region->hrm_index();
 _old_set.remove(curr_region);
 curr_region->set_free();
 curr_region->set_top(curr_region->bottom());
 if (curr_region != last_region) {
 size_t maximum_desired_capacity = (size_t) maximum_desired_capacity_d;
 // This assert only makes sense here, before we adjust them
 // with respect to the min and max heap size.
 assert(minimum_desired_capacity <= maximum_desired_capacity,
-err_msg("minimum_desired_capacity = " SIZE_FORMAT ", "
+"minimum_desired_capacity = " SIZE_FORMAT ", "
 "maximum_desired_capacity = " SIZE_FORMAT,
-minimum_desired_capacity, maximum_desired_capacity));
+minimum_desired_capacity, maximum_desired_capacity);
 // Should not be greater than the heap max size. No need to adjust
 // it with respect to the heap min size as it's a lower bound (i.e.,
 // we'll try to make the capacity larger than it, not smaller).
 minimum_desired_capacity = MIN2(minimum_desired_capacity, max_heap_size);
 }
 #endif // !PRODUCT
 void G1CollectedHeap::increment_old_marking_cycles_started() {
 assert(_old_marking_cycles_started == _old_marking_cycles_completed ||
 _old_marking_cycles_started == _old_marking_cycles_completed + 1,
-err_msg("Wrong marking cycle count (started: %d, completed: %d)",
+"Wrong marking cycle count (started: %d, completed: %d)",
-_old_marking_cycles_started, _old_marking_cycles_completed));
+_old_marking_cycles_started, _old_marking_cycles_completed);
 _old_marking_cycles_started++;
 }
 void G1CollectedHeap::increment_old_marking_cycles_completed(bool concurrent) {
 // This is the case for the inner caller, i.e. a Full GC.
 assert(concurrent ||
 (_old_marking_cycles_started == _old_marking_cycles_completed + 1) ||
 (_old_marking_cycles_started == _old_marking_cycles_completed + 2),
-err_msg("for inner caller (Full GC): _old_marking_cycles_started = %u "
+"for inner caller (Full GC): _old_marking_cycles_started = %u "
 "is inconsistent with _old_marking_cycles_completed = %u",
-_old_marking_cycles_started, _old_marking_cycles_completed));
+_old_marking_cycles_started, _old_marking_cycles_completed);
 // This is the case for the outer caller, i.e. the concurrent cycle.
 assert(!concurrent ||
 (_old_marking_cycles_started == _old_marking_cycles_completed + 1),
-err_msg("for outer caller (concurrent cycle): "
+"for outer caller (concurrent cycle): "
 "_old_marking_cycles_started = %u "
 "is inconsistent with _old_marking_cycles_completed = %u",
-_old_marking_cycles_started, _old_marking_cycles_completed));
+_old_marking_cycles_started, _old_marking_cycles_completed);
 _old_marking_cycles_completed += 1;
 // We need to clear the "in_progress" flag in the CM thread before
 // we wake up any waiters (especially when ExplicitInvokesConcurrent
 k->oops_do(_oop_closure);
 _young_ref_counter_closure.reset_count();
 k->oops_do(&_young_ref_counter_closure);
 if (_young_ref_counter_closure.count() > 0) {
-guarantee(k->has_modified_oops(), err_msg("Klass " PTR_FORMAT ", has young refs but is not dirty.", p2i(k)));
+guarantee(k->has_modified_oops(), "Klass " PTR_FORMAT ", has young refs but is not dirty.", p2i(k));
 }
 }
 };
 class VerifyLivenessOopClosure: public OopClosure {
 void do_oop(      oop *p) { do_oop_work(p); }
 template <class T> void do_oop_work(T *p) {
 oop obj = oopDesc::load_decode_heap_oop(p);
 guarantee(obj == NULL || G1MarkSweep::in_archive_range(obj),
-err_msg("Archive object at " PTR_FORMAT " references a non-archive object at " PTR_FORMAT,
+"Archive object at " PTR_FORMAT " references a non-archive object at " PTR_FORMAT,
-p2i(p), p2i(obj)));
+p2i(p), p2i(obj));
 }
 };
 class VerifyArchiveRegionClosure: public ObjectClosure {
 public:
 }
 }
 ~G1StringSymbolTableUnlinkTask() {
 guarantee(!_process_strings || StringTable::parallel_claimed_index() >= _initial_string_table_size,
-err_msg("claim value %d after unlink less than initial string table size %d",
+"claim value %d after unlink less than initial string table size %d",
-StringTable::parallel_claimed_index(), _initial_string_table_size));
+StringTable::parallel_claimed_index(), _initial_string_table_size);
 guarantee(!_process_symbols || SymbolTable::parallel_claimed_index() >= _initial_symbol_table_size,
-err_msg("claim value %d after unlink less than initial symbol table size %d",
+"claim value %d after unlink less than initial symbol table size %d",
-SymbolTable::parallel_claimed_index(), _initial_symbol_table_size));
+SymbolTable::parallel_claimed_index(), _initial_symbol_table_size);
 if (G1TraceStringSymbolTableScrubbing) {
 gclog_or_tty->print_cr("Cleaned string and symbol table, "
 "strings: " SIZE_FORMAT " processed, " SIZE_FORMAT " removed, "
 "symbols: " SIZE_FORMAT " processed, " SIZE_FORMAT " removed",
 assert( obj->is_forwarded(), "invariant" );
 *p = obj->forwardee();
 } else {
 assert(!obj->is_forwarded(), "invariant" );
 assert(cset_state.is_humongous(),
-err_msg("Only allowed InCSet state is IsHumongous, but is %d", cset_state.value()));
+"Only allowed InCSet state is IsHumongous, but is %d", cset_state.value());
 _g1->set_humongous_is_live(obj);
 }
 }
 };
 if (_g1h->is_in_g1_reserved(p)) {
 _par_scan_state->push_on_queue(p);
 } else {
 assert(!Metaspace::contains((const void*)p),
-err_msg("Unexpectedly found a pointer from metadata: " PTR_FORMAT, p2i(p)));
+"Unexpectedly found a pointer from metadata: " PTR_FORMAT, p2i(p));
 _copy_non_heap_obj_cl->do_oop(p);
 }
 }
 }
 };
 }
 bool G1CollectedHeap::verify_no_bits_over_tams(const char* bitmap_name, CMBitMapRO* bitmap,
 HeapWord* tams, HeapWord* end) {
 guarantee(tams <= end,
-err_msg("tams: " PTR_FORMAT " end: " PTR_FORMAT, p2i(tams), p2i(end)));
+"tams: " PTR_FORMAT " end: " PTR_FORMAT, p2i(tams), p2i(end));
 HeapWord* result = bitmap->getNextMarkedWordAddress(tams, end);
 if (result < end) {
 gclog_or_tty->cr();
 gclog_or_tty->print_cr("## wrong marked address on %s bitmap: " PTR_FORMAT,
 bitmap_name, p2i(result));
 return false;
 }
 guarantee(obj->is_typeArray(),
-err_msg("Only eagerly reclaiming type arrays is supported, but the object "
+"Only eagerly reclaiming type arrays is supported, but the object "
-PTR_FORMAT " is not.",
+PTR_FORMAT " is not.", p2i(r->bottom()));
-p2i(r->bottom())));
 if (G1TraceEagerReclaimHumongousObjects) {
 gclog_or_tty->print_cr("Dead humongous region %u size " SIZE_FORMAT " start " PTR_FORMAT " length %u with remset " SIZE_FORMAT " code roots " SIZE_FORMAT " is marked %d reclaim candidate %d type array %d",
 region_idx,
 (size_t)obj->size() * HeapWordSize,
 _summary_bytes_used += bytes;
 }
 void G1CollectedHeap::decrease_used(size_t bytes) {
 assert(_summary_bytes_used >= bytes,
-err_msg("invariant: _summary_bytes_used: " SIZE_FORMAT " should be >= bytes: " SIZE_FORMAT,
+"invariant: _summary_bytes_used: " SIZE_FORMAT " should be >= bytes: " SIZE_FORMAT,
-_summary_bytes_used, bytes));
+_summary_bytes_used, bytes);
 _summary_bytes_used -= bytes;
 }
 void G1CollectedHeap::set_used(size_t bytes) {
 _summary_bytes_used = bytes;
 if (_archive_allocator != NULL) {
 _archive_allocator->clear_used();
 }
 }
 assert(used_unlocked() == recalculate_used(),
-err_msg("inconsistent used_unlocked(), "
+"inconsistent used_unlocked(), "
 "value: " SIZE_FORMAT " recalculated: " SIZE_FORMAT,
-used_unlocked(), recalculate_used()));
+used_unlocked(), recalculate_used());
 }
 void G1CollectedHeap::set_refine_cte_cl_concurrency(bool concurrent) {
 _refine_cte_cl->set_concurrent(concurrent);
 }
 }
 if (hr->is_young()) {
 // TODO
 } else if (hr->is_starts_humongous()) {
-assert(hr->containing_set() == _humongous_set, err_msg("Heap region %u is starts humongous but not in humongous set.", hr->hrm_index()));
+assert(hr->containing_set() == _humongous_set, "Heap region %u is starts humongous but not in humongous set.", hr->hrm_index());
 _humongous_count.increment(1u, hr->capacity());
 } else if (hr->is_empty()) {
-assert(_hrm->is_free(hr), err_msg("Heap region %u is empty but not on the free list.", hr->hrm_index()));
+assert(_hrm->is_free(hr), "Heap region %u is empty but not on the free list.", hr->hrm_index());
 _free_count.increment(1u, hr->capacity());
 } else if (hr->is_old()) {
-assert(hr->containing_set() == _old_set, err_msg("Heap region %u is old but not in the old set.", hr->hrm_index()));
+assert(hr->containing_set() == _old_set, "Heap region %u is old but not in the old set.", hr->hrm_index());
 _old_count.increment(1u, hr->capacity());
 } else {
 // There are no other valid region types. Check for one invalid
 // one we can identify: pinned without old or humongous set.
-assert(!hr->is_pinned(), err_msg("Heap region %u is pinned but not old (archive) or humongous.", hr->hrm_index()));
+assert(!hr->is_pinned(), "Heap region %u is pinned but not old (archive) or humongous.", hr->hrm_index());
 ShouldNotReachHere();
 }
 return false;
 }
 void verify_counts(HeapRegionSet* old_set, HeapRegionSet* humongous_set, HeapRegionManager* free_list) {
-guarantee(old_set->length() == _old_count.length(), err_msg("Old set count mismatch. Expected %u, actual %u.", old_set->length(), _old_count.length()));
+guarantee(old_set->length() == _old_count.length(), "Old set count mismatch. Expected %u, actual %u.", old_set->length(), _old_count.length());
-guarantee(old_set->total_capacity_bytes() == _old_count.capacity(), err_msg("Old set capacity mismatch. Expected " SIZE_FORMAT ", actual " SIZE_FORMAT,
+guarantee(old_set->total_capacity_bytes() == _old_count.capacity(), "Old set capacity mismatch. Expected " SIZE_FORMAT ", actual " SIZE_FORMAT,
-old_set->total_capacity_bytes(), _old_count.capacity()));
+old_set->total_capacity_bytes(), _old_count.capacity());
-guarantee(humongous_set->length() == _humongous_count.length(), err_msg("Hum set count mismatch. Expected %u, actual %u.", humongous_set->length(), _humongous_count.length()));
+guarantee(humongous_set->length() == _humongous_count.length(), "Hum set count mismatch. Expected %u, actual %u.", humongous_set->length(), _humongous_count.length());
-guarantee(humongous_set->total_capacity_bytes() == _humongous_count.capacity(), err_msg("Hum set capacity mismatch. Expected " SIZE_FORMAT ", actual " SIZE_FORMAT,
+guarantee(humongous_set->total_capacity_bytes() == _humongous_count.capacity(), "Hum set capacity mismatch. Expected " SIZE_FORMAT ", actual " SIZE_FORMAT,
-humongous_set->total_capacity_bytes(), _humongous_count.capacity()));
+humongous_set->total_capacity_bytes(), _humongous_count.capacity());
-guarantee(free_list->num_free_regions() == _free_count.length(), err_msg("Free list count mismatch. Expected %u, actual %u.", free_list->num_free_regions(), _free_count.length()));
+guarantee(free_list->num_free_regions() == _free_count.length(), "Free list count mismatch. Expected %u, actual %u.", free_list->num_free_regions(), _free_count.length());
-guarantee(free_list->total_capacity_bytes() == _free_count.capacity(), err_msg("Free list capacity mismatch. Expected " SIZE_FORMAT ", actual " SIZE_FORMAT,
+guarantee(free_list->total_capacity_bytes() == _free_count.capacity(), "Free list capacity mismatch. Expected " SIZE_FORMAT ", actual " SIZE_FORMAT,
-free_list->total_capacity_bytes(), _free_count.capacity()));
+free_list->total_capacity_bytes(), _free_count.capacity());
 }
 };
 void G1CollectedHeap::verify_region_sets() {
 assert_heap_locked_or_at_safepoint(true /* should_be_vm_thread */);
 T heap_oop = oopDesc::load_heap_oop(p);
 if (!oopDesc::is_null(heap_oop)) {
 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
 HeapRegion* hr = _g1h->heap_region_containing(obj);
 assert(!hr->is_continues_humongous(),
-err_msg("trying to add code root " PTR_FORMAT " in continuation of humongous region " HR_FORMAT
+"trying to add code root " PTR_FORMAT " in continuation of humongous region " HR_FORMAT
 " starting at " HR_FORMAT,
-p2i(_nm), HR_FORMAT_PARAMS(hr), HR_FORMAT_PARAMS(hr->humongous_start_region())));
+p2i(_nm), HR_FORMAT_PARAMS(hr), HR_FORMAT_PARAMS(hr->humongous_start_region()));
 // HeapRegion::add_strong_code_root_locked() avoids adding duplicate entries.
 hr->add_strong_code_root_locked(_nm);
 }
 }
 T heap_oop = oopDesc::load_heap_oop(p);
 if (!oopDesc::is_null(heap_oop)) {
 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
 HeapRegion* hr = _g1h->heap_region_containing(obj);
 assert(!hr->is_continues_humongous(),
-err_msg("trying to remove code root " PTR_FORMAT " in continuation of humongous region " HR_FORMAT
+"trying to remove code root " PTR_FORMAT " in continuation of humongous region " HR_FORMAT
 " starting at " HR_FORMAT,
-p2i(_nm), HR_FORMAT_PARAMS(hr), HR_FORMAT_PARAMS(hr->humongous_start_region())));
+p2i(_nm), HR_FORMAT_PARAMS(hr), HR_FORMAT_PARAMS(hr->humongous_start_region()));
 hr->remove_strong_code_root(_nm);
 }
 }

changeset 33105	294e48b4f704
parent 32818	87014063ec81
child 33107	77bf0d2069a3