--- a/hotspot/src/share/vm/gc/g1/g1CollectedHeap.cpp Mon Sep 28 15:05:02 2015 +0200
+++ b/hotspot/src/share/vm/gc/g1/g1CollectedHeap.cpp Tue Sep 29 11:02:08 2015 +0200
@@ -971,11 +971,11 @@
size_t commits = 0;
guarantee(reserved.contains(start_address) && reserved.contains(last_address),
- err_msg("MemRegion outside of heap [" PTR_FORMAT ", " PTR_FORMAT "]",
- p2i(start_address), p2i(last_address)));
+ "MemRegion outside of heap [" PTR_FORMAT ", " PTR_FORMAT "]",
+ p2i(start_address), p2i(last_address));
guarantee(start_address > prev_last_addr,
- err_msg("Ranges not in ascending order: " PTR_FORMAT " <= " PTR_FORMAT ,
- p2i(start_address), p2i(prev_last_addr)));
+ "Ranges not in ascending order: " PTR_FORMAT " <= " PTR_FORMAT ,
+ 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
@@ -1017,7 +1017,7 @@
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();
@@ -1055,11 +1055,11 @@
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 "]",
- p2i(start_address), p2i(last_address)));
+ "MemRegion outside of heap [" PTR_FORMAT ", " PTR_FORMAT "]",
+ p2i(start_address), p2i(last_address));
assert(start_address > prev_last_addr,
- err_msg("Ranges not in ascending order: " PTR_FORMAT " <= " PTR_FORMAT ,
- p2i(start_address), p2i(prev_last_addr)));
+ "Ranges not in ascending order: " PTR_FORMAT " <= " PTR_FORMAT ,
+ 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);
@@ -1076,7 +1076,7 @@
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 {
@@ -1139,11 +1139,11 @@
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 "]",
- p2i(start_address), p2i(last_address)));
+ "MemRegion outside of heap [" PTR_FORMAT ", " PTR_FORMAT "]",
+ p2i(start_address), p2i(last_address));
assert(start_address > prev_last_addr,
- err_msg("Ranges not in ascending order: " PTR_FORMAT " <= " PTR_FORMAT ,
- p2i(start_address), p2i(prev_last_addr)));
+ "Ranges not in ascending order: " PTR_FORMAT " <= " PTR_FORMAT ,
+ p2i(start_address), p2i(prev_last_addr));
size_used += ranges[i].byte_size();
prev_last_addr = last_address;
@@ -1168,7 +1168,7 @@
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();
@@ -1755,9 +1755,9 @@
// 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 ", "
- "maximum_desired_capacity = " SIZE_FORMAT,
- minimum_desired_capacity, maximum_desired_capacity));
+ "minimum_desired_capacity = " SIZE_FORMAT ", "
+ "maximum_desired_capacity = " SIZE_FORMAT,
+ 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.,
@@ -2538,9 +2538,9 @@
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)",
- _old_marking_cycles_started, _old_marking_cycles_completed));
+ _old_marking_cycles_started == _old_marking_cycles_completed + 1,
+ "Wrong marking cycle count (started: %d, completed: %d)",
+ _old_marking_cycles_started, _old_marking_cycles_completed);
_old_marking_cycles_started++;
}
@@ -2564,17 +2564,17 @@
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 "
- "is inconsistent with _old_marking_cycles_completed = %u",
- _old_marking_cycles_started, _old_marking_cycles_completed));
+ "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);
// 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): "
- "_old_marking_cycles_started = %u "
- "is inconsistent with _old_marking_cycles_completed = %u",
- _old_marking_cycles_started, _old_marking_cycles_completed));
+ "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_completed += 1;
@@ -3124,7 +3124,7 @@
_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));
}
}
};
@@ -3194,8 +3194,8 @@
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,
- p2i(p), p2i(obj)));
+ "Archive object at " PTR_FORMAT " references a non-archive object at " PTR_FORMAT,
+ p2i(p), p2i(obj));
}
};
@@ -4709,11 +4709,11 @@
~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",
- StringTable::parallel_claimed_index(), _initial_string_table_size));
+ "claim value %d after unlink less than initial string table size %d",
+ 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",
- SymbolTable::parallel_claimed_index(), _initial_symbol_table_size));
+ "claim value %d after unlink less than initial symbol table size %d",
+ SymbolTable::parallel_claimed_index(), _initial_symbol_table_size);
if (G1TraceStringSymbolTableScrubbing) {
gclog_or_tty->print_cr("Cleaned string and symbol table, "
@@ -5113,7 +5113,7 @@
} 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);
}
}
@@ -5167,7 +5167,7 @@
_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);
}
}
@@ -5823,7 +5823,7 @@
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();
@@ -6174,9 +6174,8 @@
}
guarantee(obj->is_typeArray(),
- err_msg("Only eagerly reclaiming type arrays is supported, but the object "
- PTR_FORMAT " is not.",
- p2i(r->bottom())));
+ "Only eagerly reclaiming type arrays is supported, but the object "
+ PTR_FORMAT " is not.", 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",
@@ -6405,8 +6404,8 @@
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,
- _summary_bytes_used, bytes));
+ "invariant: _summary_bytes_used: " SIZE_FORMAT " should be >= bytes: " SIZE_FORMAT,
+ _summary_bytes_used, bytes);
_summary_bytes_used -= bytes;
}
@@ -6488,9 +6487,9 @@
}
}
assert(used_unlocked() == recalculate_used(),
- err_msg("inconsistent used_unlocked(), "
- "value: " SIZE_FORMAT " recalculated: " SIZE_FORMAT,
- used_unlocked(), recalculate_used()));
+ "inconsistent used_unlocked(), "
+ "value: " SIZE_FORMAT " recalculated: " SIZE_FORMAT,
+ used_unlocked(), recalculate_used());
}
void G1CollectedHeap::set_refine_cte_cl_concurrency(bool concurrent) {
@@ -6631,35 +6630,35 @@
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->total_capacity_bytes() == _old_count.capacity(), err_msg("Old set capacity mismatch. Expected " SIZE_FORMAT ", actual " SIZE_FORMAT,
- 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->total_capacity_bytes() == _humongous_count.capacity(), err_msg("Hum set capacity mismatch. Expected " SIZE_FORMAT ", actual " SIZE_FORMAT,
- 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->total_capacity_bytes() == _free_count.capacity(), err_msg("Free list capacity mismatch. Expected " SIZE_FORMAT ", actual " SIZE_FORMAT,
- free_list->total_capacity_bytes(), _free_count.capacity()));
+ 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(), "Old set capacity mismatch. Expected " SIZE_FORMAT ", actual " SIZE_FORMAT,
+ old_set->total_capacity_bytes(), _old_count.capacity());
+
+ 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(), "Hum set capacity mismatch. Expected " SIZE_FORMAT ", actual " SIZE_FORMAT,
+ humongous_set->total_capacity_bytes(), _humongous_count.capacity());
+
+ 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(), "Free list capacity mismatch. Expected " SIZE_FORMAT ", actual " SIZE_FORMAT,
+ free_list->total_capacity_bytes(), _free_count.capacity());
}
};
@@ -6715,9 +6714,9 @@
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
- " starting at " HR_FORMAT,
- p2i(_nm), HR_FORMAT_PARAMS(hr), HR_FORMAT_PARAMS(hr->humongous_start_region())));
+ "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()));
// HeapRegion::add_strong_code_root_locked() avoids adding duplicate entries.
hr->add_strong_code_root_locked(_nm);
@@ -6742,9 +6741,9 @@
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
- " starting at " HR_FORMAT,
- p2i(_nm), HR_FORMAT_PARAMS(hr), HR_FORMAT_PARAMS(hr->humongous_start_region())));
+ "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()));
hr->remove_strong_code_root(_nm);
}