graal-compiler: src/share/vm/gc_implementation/g1/concurrentMark.cpp comparison

comparison src/share/vm/gc_implementation/g1/concurrentMark.cpp @ 18041:52b4284cb496

Merge with jdk8u20-b26

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Wed, 15 Oct 2014 16:02:50 +0200
parents	4ca6dc0799b6 8a140676873f
children	7848fc12602b

comparison

equal deleted inserted replaced

-:45d7b2c7029d
+:52b4284cb496
 /*
-* Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2001, 2014, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 }
 _verbose_level = verbose_level;
 if (verbose_low()) {
 gclog_or_tty->print_cr("[global] init, heap start = "PTR_FORMAT", "
-"heap end = "PTR_FORMAT, _heap_start, _heap_end);
+"heap end = " INTPTR_FORMAT, p2i(_heap_start), p2i(_heap_end));
 }
 if (!_markBitMap1.allocate(heap_rs)) {
 warning("Failed to allocate first CM bit map");
 return;
 satb_qs.set_buffer_size(G1SATBBufferSize);
 _root_regions.init(_g1h, this);
 if (ConcGCThreads > ParallelGCThreads) {
-warning("Can't have more ConcGCThreads (" UINT32_FORMAT ") "
+warning("Can't have more ConcGCThreads (" UINTX_FORMAT ") "
-"than ParallelGCThreads (" UINT32_FORMAT ").",
+"than ParallelGCThreads (" UINTX_FORMAT ").",
 ConcGCThreads, ParallelGCThreads);
 return;
 }
 if (ParallelGCThreads == 0) {
 // if we are not running with any parallel GC threads we will not
 // Verify that the calculated value for MarkStackSize is in range.
 // It would be nice to use the private utility routine from Arguments.
 if (!(mark_stack_size >= 1 && mark_stack_size <= MarkStackSizeMax)) {
 warning("Invalid value calculated for MarkStackSize (" UINTX_FORMAT "): "
 "must be between " UINTX_FORMAT " and " UINTX_FORMAT,
-mark_stack_size, 1, MarkStackSizeMax);
+mark_stack_size, (uintx) 1, MarkStackSizeMax);
 return;
 }
 FLAG_SET_ERGO(uintx, MarkStackSize, mark_stack_size);
 } else {
 // Verify MarkStackSize is in range.
 if (FLAG_IS_CMDLINE(MarkStackSize)) {
 if (FLAG_IS_DEFAULT(MarkStackSizeMax)) {
 if (!(MarkStackSize >= 1 && MarkStackSize <= MarkStackSizeMax)) {
 warning("Invalid value specified for MarkStackSize (" UINTX_FORMAT "): "
 "must be between " UINTX_FORMAT " and " UINTX_FORMAT,
-MarkStackSize, 1, MarkStackSizeMax);
+MarkStackSize, (uintx) 1, MarkStackSizeMax);
 return;
 }
 } else if (FLAG_IS_CMDLINE(MarkStackSizeMax)) {
 if (!(MarkStackSize >= 1 && MarkStackSize <= MarkStackSizeMax)) {
 warning("Invalid value specified for MarkStackSize (" UINTX_FORMAT ")"
 } else {
 // We currently assume that the concurrent flag has been set to
 // false before we start remark. At this point we should also be
 // in a STW phase.
 assert(!concurrent_marking_in_progress(), "invariant");
-assert(_finger == _heap_end,
+assert(out_of_regions(),
 err_msg("only way to get here: _finger: "PTR_FORMAT", _heap_end: "PTR_FORMAT,
-_finger, _heap_end));
+p2i(_finger), p2i(_heap_end)));
 update_g1_committed(true);
 }
 }
 void ConcurrentMark::set_non_marking_state() {
 }
 if (concurrent()) {
 ConcurrentGCThread::stsLeave();
 }
-_first_overflow_barrier_sync.enter();
+bool barrier_aborted = !_first_overflow_barrier_sync.enter();
 if (concurrent()) {
 ConcurrentGCThread::stsJoin();
 }
 // at this point everyone should have synced up and not be doing any
 // more work
 if (verbose_low()) {
-gclog_or_tty->print_cr("[%u] leaving first barrier", worker_id);
+if (barrier_aborted) {
+gclog_or_tty->print_cr("[%u] aborted first barrier", worker_id);
+} else {
+gclog_or_tty->print_cr("[%u] leaving first barrier", worker_id);
+}
+}
+if (barrier_aborted) {
+// If the barrier aborted we ignore the overflow condition and
+// just abort the whole marking phase as quickly as possible.
+return;
 }
 // If we're executing the concurrent phase of marking, reset the marking
 // state; otherwise the marking state is reset after reference processing,
 // during the remark pause.
 }
 if (concurrent()) {
 ConcurrentGCThread::stsLeave();
 }
-_second_overflow_barrier_sync.enter();
+bool barrier_aborted = !_second_overflow_barrier_sync.enter();
 if (concurrent()) {
 ConcurrentGCThread::stsJoin();
 }
 // at this point everything should be re-initialized and ready to go
 if (verbose_low()) {
-gclog_or_tty->print_cr("[%u] leaving second barrier", worker_id);
+if (barrier_aborted) {
+gclog_or_tty->print_cr("[%u] aborted second barrier", worker_id);
+} else {
+gclog_or_tty->print_cr("[%u] leaving second barrier", worker_id);
+}
 }
 }
 #ifndef PRODUCT
 void ForceOverflowSettings::init() {
 HeapWord* start = hr->bottom();
 assert(start <= hr->end() && start <= ntams && ntams <= hr->end(),
 err_msg("Preconditions not met - "
 "start: "PTR_FORMAT", ntams: "PTR_FORMAT", end: "PTR_FORMAT,
-start, ntams, hr->end()));
+p2i(start), p2i(ntams), p2i(hr->end())));
 // Find the first marked object at or after "start".
 start = _bm->getNextMarkedWordAddress(start, ntams);
 size_t marked_bytes = 0;
 }
 if (failures > 0 && _verbose)  {
 gclog_or_tty->print_cr("Region " HR_FORMAT ", ntams: " PTR_FORMAT ", "
 "marked_bytes: calc/actual " SIZE_FORMAT "/" SIZE_FORMAT,
-HR_FORMAT_PARAMS(hr), hr->next_top_at_mark_start(),
+HR_FORMAT_PARAMS(hr), p2i(hr->next_top_at_mark_start()),
 _calc_cl.region_marked_bytes(), hr->next_marked_bytes());
 }
 _failures += failures;
 // We could stop iteration over the heap when we
 // find the first violating region by returning true.
 return false;
 }
 };
 class G1ParVerifyFinalCountTask: public AbstractGangTask {
 protected:
 G1CollectedHeap* _g1h;
 ConcurrentMark* _cm;
 class G1ParNoteEndTask;
 class G1NoteEndOfConcMarkClosure : public HeapRegionClosure {
 G1CollectedHeap* _g1;
-int _worker_num;
 size_t _max_live_bytes;
 uint _regions_claimed;
 size_t _freed_bytes;
 FreeRegionList* _local_cleanup_list;
-OldRegionSet* _old_proxy_set;
+HeapRegionSetCount _old_regions_removed;
-HumongousRegionSet* _humongous_proxy_set;
+HeapRegionSetCount _humongous_regions_removed;
 HRRSCleanupTask* _hrrs_cleanup_task;
 double _claimed_region_time;
 double _max_region_time;
 public:
 G1NoteEndOfConcMarkClosure(G1CollectedHeap* g1,
-int worker_num,
 FreeRegionList* local_cleanup_list,
-OldRegionSet* old_proxy_set,
-HumongousRegionSet* humongous_proxy_set,
 HRRSCleanupTask* hrrs_cleanup_task) :
-_g1(g1), _worker_num(worker_num),
+_g1(g1),
 _max_live_bytes(0), _regions_claimed(0),
 _freed_bytes(0),
 _claimed_region_time(0.0), _max_region_time(0.0),
 _local_cleanup_list(local_cleanup_list),
-_old_proxy_set(old_proxy_set),
+_old_regions_removed(),
-_humongous_proxy_set(humongous_proxy_set),
+_humongous_regions_removed(),
 _hrrs_cleanup_task(hrrs_cleanup_task) { }
 size_t freed_bytes() { return _freed_bytes; }
+const HeapRegionSetCount& old_regions_removed() { return _old_regions_removed; }
+const HeapRegionSetCount& humongous_regions_removed() { return _humongous_regions_removed; }
 bool doHeapRegion(HeapRegion *hr) {
 if (hr->continuesHumongous()) {
 return false;
 }
 _g1->reset_gc_time_stamps(hr);
 double start = os::elapsedTime();
 _regions_claimed++;
 hr->note_end_of_marking();
 _max_live_bytes += hr->max_live_bytes();
-_g1->free_region_if_empty(hr,
-&_freed_bytes,
+if (hr->used() > 0 && hr->max_live_bytes() == 0 && !hr->is_young()) {
-_local_cleanup_list,
+_freed_bytes += hr->used();
-_old_proxy_set,
+hr->set_containing_set(NULL);
-_humongous_proxy_set,
+if (hr->isHumongous()) {
-_hrrs_cleanup_task,
+assert(hr->startsHumongous(), "we should only see starts humongous");
-true /* par */);
+_humongous_regions_removed.increment(1u, hr->capacity());
+_g1->free_humongous_region(hr, _local_cleanup_list, true);
+} else {
+_old_regions_removed.increment(1u, hr->capacity());
+_g1->free_region(hr, _local_cleanup_list, true);
+}
+} else {
+hr->rem_set()->do_cleanup_work(_hrrs_cleanup_task);
+}
 double region_time = (os::elapsedTime() - start);
 _claimed_region_time += region_time;
 if (region_time > _max_region_time) {
 _max_region_time = region_time;
 }
 _max_live_bytes(0), _freed_bytes(0), _cleanup_list(cleanup_list) { }
 void work(uint worker_id) {
 double start = os::elapsedTime();
 FreeRegionList local_cleanup_list("Local Cleanup List");
-OldRegionSet old_proxy_set("Local Cleanup Old Proxy Set");
-HumongousRegionSet humongous_proxy_set("Local Cleanup Humongous Proxy Set");
 HRRSCleanupTask hrrs_cleanup_task;
-G1NoteEndOfConcMarkClosure g1_note_end(_g1h, worker_id, &local_cleanup_list,
+G1NoteEndOfConcMarkClosure g1_note_end(_g1h, &local_cleanup_list,
-&old_proxy_set,
-&humongous_proxy_set,
 &hrrs_cleanup_task);
 if (G1CollectedHeap::use_parallel_gc_threads()) {
 _g1h->heap_region_par_iterate_chunked(&g1_note_end, worker_id,
 _g1h->workers()->active_workers(),
 HeapRegion::NoteEndClaimValue);
 _g1h->heap_region_iterate(&g1_note_end);
 }
 assert(g1_note_end.complete(), "Shouldn't have yielded!");
 // Now update the lists
-_g1h->update_sets_after_freeing_regions(g1_note_end.freed_bytes(),
+_g1h->remove_from_old_sets(g1_note_end.old_regions_removed(), g1_note_end.humongous_regions_removed());
-NULL /* free_list */,
-&old_proxy_set,
-&humongous_proxy_set,
-true /* par */);
 {
 MutexLockerEx x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag);
+_g1h->decrement_summary_bytes(g1_note_end.freed_bytes());
 _max_live_bytes += g1_note_end.max_live_bytes();
 _freed_bytes += g1_note_end.freed_bytes();
 // If we iterate over the global cleanup list at the end of
 // cleanup to do this printing we will not guarantee to only
 // printing here, before we append the new regions to the global
 // cleanup list.
 G1HRPrinter* hr_printer = _g1h->hr_printer();
 if (hr_printer->is_active()) {
-HeapRegionLinkedListIterator iter(&local_cleanup_list);
+FreeRegionListIterator iter(&local_cleanup_list);
 while (iter.more_available()) {
 HeapRegion* hr = iter.get_next();
 hr_printer->cleanup(hr);
 }
 }
-_cleanup_list->add_as_tail(&local_cleanup_list);
+_cleanup_list->add_ordered(&local_cleanup_list);
 assert(local_cleanup_list.is_empty(), "post-condition");
 HeapRegionRemSet::finish_cleanup_task(&hrrs_cleanup_task);
 }
 }
 if (has_aborted()) {
 g1h->set_marking_complete(); // So bitmap clearing isn't confused
 return;
 }
-HRSPhaseSetter x(HRSPhaseCleanup);
 g1h->verify_region_sets_optional();
 if (VerifyDuringGC) {
 HandleMark hm;  // handle scope
 Universe::heap()->prepare_for_verify();
 // Noone else should be accessing the _cleanup_list at this point,
 // so it's not necessary to take any locks
 while (!_cleanup_list.is_empty()) {
 HeapRegion* hr = _cleanup_list.remove_head();
-assert(hr != NULL, "the list was not empty");
+assert(hr != NULL, "Got NULL from a non-empty list");
 hr->par_clear();
-tmp_free_list.add_as_tail(hr);
+tmp_free_list.add_ordered(hr);
 // Instead of adding one region at a time to the secondary_free_list,
 // we accumulate them in the local list and move them a few at a
 // time. This also cuts down on the number of notify_all() calls
 // we do during this process. We'll also append the local list when
 _cleanup_list.length());
 }
 {
 MutexLockerEx x(SecondaryFreeList_lock, Mutex::_no_safepoint_check_flag);
-g1h->secondary_free_list_add_as_tail(&tmp_free_list);
+g1h->secondary_free_list_add(&tmp_free_list);
 SecondaryFreeList_lock->notify_all();
 }
 if (G1StressConcRegionFreeing) {
 for (uintx i = 0; i < G1StressConcRegionFreeingDelayMillis; ++i) {
 if (!_cm->has_overflown()) {
 oop obj = oopDesc::load_decode_heap_oop(p);
 if (_cm->verbose_high()) {
 gclog_or_tty->print_cr("\t[%u] we're looking at location "
 "*"PTR_FORMAT" = "PTR_FORMAT,
-_task->worker_id(), p, (void*) obj);
+_task->worker_id(), p2i(p), p2i((void*) obj));
 }
 _task->deal_with_reference(obj);
 _ref_counter--;
 rp->verify_no_references_recorded();
 assert(!rp->discovery_enabled(), "Post condition");
 }
-// Now clean up stale oops in StringTable
+if (has_overflown()) {
-StringTable::unlink(&g1_is_alive);
+// We can not trust g1_is_alive if the marking stack overflowed
-// Clean up unreferenced symbols in symbol table.
+return;
-SymbolTable::unlink();
+}
+g1h->unlink_string_and_symbol_table(&g1_is_alive,
+/* process_strings */ false, // currently strings are always roots
+/* process_symbols */ true);
 }
 void ConcurrentMark::swapMarkBitMaps() {
 CMBitMapRO* temp = _prevMarkBitMap;
 _prevMarkBitMap  = (CMBitMapRO*)_nextMarkBitMap;
 str = " NOT";
 }
 }
 _out->print_cr("  "PTR_FORMAT": "PTR_FORMAT"%s%s",
-p, (void*) obj, str, str2);
+p2i(p), p2i((void*) obj), str, str2);
 }
 };
 class PrintReachableObjectClosure : public ObjectClosure {
 private:
 bool marked = _g1h->is_marked(o, _vo);
 bool print_it = _all || over_tams || marked;
 if (print_it) {
 _out->print_cr(" "PTR_FORMAT"%s",
-(void *)o, (over_tams) ? " >" : (marked) ? " M" : "");
+p2i((void *)o), (over_tams) ? " >" : (marked) ? " M" : "");
 PrintReachableOopClosure oopCl(_out, _vo, _all);
 o->oop_iterate_no_header(&oopCl);
 }
 }
 };
 HeapWord* b = hr->bottom();
 HeapWord* e = hr->end();
 HeapWord* t = hr->top();
 HeapWord* p = _g1h->top_at_mark_start(hr, _vo);
 _out->print_cr("** ["PTR_FORMAT", "PTR_FORMAT"] top: "PTR_FORMAT" "
-"TAMS: "PTR_FORMAT, b, e, t, p);
+"TAMS: " PTR_FORMAT, p2i(b), p2i(e), p2i(t), p2i(p));
 _out->cr();
 HeapWord* from = b;
 HeapWord* to   = t;
 if (to > from) {
-_out->print_cr("Objects in ["PTR_FORMAT", "PTR_FORMAT"]", from, to);
+_out->print_cr("Objects in [" PTR_FORMAT ", " PTR_FORMAT "]", p2i(from), p2i(to));
 _out->cr();
 PrintReachableObjectClosure ocl(_out, _vo, _all, hr);
 hr->object_iterate_mem_careful(MemRegion(from, to), &ocl);
 _out->cr();
 }
 if (verbose_low()) {
 gclog_or_tty->print_cr("[%u] curr_region = "PTR_FORMAT" "
 "["PTR_FORMAT", "PTR_FORMAT"), "
 "limit = "PTR_FORMAT,
-worker_id, curr_region, bottom, end, limit);
+worker_id, p2i(curr_region), p2i(bottom), p2i(end), p2i(limit));
 }
 // Is the gap between reading the finger and doing the CAS too long?
 HeapWord* res = (HeapWord*) Atomic::cmpxchg_ptr(end, &_finger, finger);
 if (res == finger) {
 // someone else might have moved the finger even further
 assert(_finger >= end, "the finger should have moved forward");
 if (verbose_low()) {
 gclog_or_tty->print_cr("[%u] we were successful with region = "
-PTR_FORMAT, worker_id, curr_region);
+PTR_FORMAT, worker_id, p2i(curr_region));
 }
 if (limit > bottom) {
 if (verbose_low()) {
 gclog_or_tty->print_cr("[%u] region "PTR_FORMAT" is not empty, "
-"returning it ", worker_id, curr_region);
+"returning it ", worker_id, p2i(curr_region));
 }
 return curr_region;
 } else {
 assert(limit == bottom,
 "the region limit should be at bottom");
 if (verbose_low()) {
 gclog_or_tty->print_cr("[%u] region "PTR_FORMAT" is empty, "
-"returning NULL", worker_id, curr_region);
+"returning NULL", worker_id, p2i(curr_region));
 }
 // we return NULL and the caller should try calling
 // claim_region() again.
 return NULL;
 }
 assert(_finger > finger, "the finger should have moved forward");
 if (verbose_low()) {
 gclog_or_tty->print_cr("[%u] somebody else moved the finger, "
 "global finger = "PTR_FORMAT", "
 "our finger = "PTR_FORMAT,
-worker_id, _finger, finger);
+worker_id, p2i(_finger), p2i(finger));
 }
 // read it again
 finger = _finger;
 }
 }
 void do_object_work(oop obj) {
 guarantee(!_g1h->obj_in_cs(obj),
 err_msg("obj: "PTR_FORMAT" in CSet, phase: %s, info: %d",
-(void*) obj, phase_str(), _info));
+p2i((void*) obj), phase_str(), _info));
 }
 public:
 VerifyNoCSetOopsClosure() : _g1h(G1CollectedHeap::heap()) { }
 // corresponding starts humongous region and the check below will
 // not hold any more.
 HeapRegion* global_hr = _g1h->heap_region_containing_raw(global_finger);
 guarantee(global_finger == global_hr->bottom(),
 err_msg("global finger: "PTR_FORMAT" region: "HR_FORMAT,
-global_finger, HR_FORMAT_PARAMS(global_hr)));
+p2i(global_finger), HR_FORMAT_PARAMS(global_hr)));
 }
 // Verify the task fingers
 assert(parallel_marking_threads() <= _max_worker_id, "sanity");
 for (int i = 0; i < (int) parallel_marking_threads(); i += 1) {
 // See above note on the global finger verification.
 HeapRegion* task_hr = _g1h->heap_region_containing_raw(task_finger);
 guarantee(task_finger == task_hr->bottom() ||
 !task_hr->in_collection_set(),
 err_msg("task finger: "PTR_FORMAT" region: "HR_FORMAT,
-task_finger, HR_FORMAT_PARAMS(task_hr)));
+p2i(task_finger), HR_FORMAT_PARAMS(task_hr)));
 }
 }
 }
 }
 #endif // PRODUCT
 assert(start <= limit && limit <= hr->top() && hr->top() <= hr->end(),
 err_msg("Preconditions not met - "
 "start: "PTR_FORMAT", limit: "PTR_FORMAT", "
 "top: "PTR_FORMAT", end: "PTR_FORMAT,
-start, limit, hr->top(), hr->end()));
+p2i(start), p2i(limit), p2i(hr->top()), p2i(hr->end())));
 assert(hr->next_marked_bytes() == 0, "Precondition");
 if (start == limit) {
 // NTAMS of this region has not been set so nothing to do.
 // Empty mark stack
 reset_marking_state();
 for (uint i = 0; i < _max_worker_id; ++i) {
 _tasks[i]->clear_region_fields();
 }
+_first_overflow_barrier_sync.abort();
+_second_overflow_barrier_sync.abort();
 _has_aborted = true;
 SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set();
 satb_mq_set.abandon_partial_marking();
 // This can be called either during or outside marking, we'll read
 }
 }
 void ConcurrentMark::print_on_error(outputStream* st) const {
 st->print_cr("Marking Bits (Prev, Next): (CMBitMap*) " PTR_FORMAT ", (CMBitMap*) " PTR_FORMAT,
-_prevMarkBitMap, _nextMarkBitMap);
+p2i(_prevMarkBitMap), p2i(_nextMarkBitMap));
 _prevMarkBitMap->print_on_error(st, " Prev Bits: ");
 _nextMarkBitMap->print_on_error(st, " Next Bits: ");
 }
 // We take a break if someone is trying to stop the world.
 #ifndef PRODUCT
 // for debugging purposes
 void ConcurrentMark::print_finger() {
 gclog_or_tty->print_cr("heap ["PTR_FORMAT", "PTR_FORMAT"), global finger = "PTR_FORMAT,
-_heap_start, _heap_end, _finger);
+p2i(_heap_start), p2i(_heap_end), p2i(_finger));
 for (uint i = 0; i < _max_worker_id; ++i) {
-gclog_or_tty->print("   %u: "PTR_FORMAT, i, _tasks[i]->finger());
+gclog_or_tty->print("   %u: " PTR_FORMAT, i, p2i(_tasks[i]->finger()));
 }
-gclog_or_tty->print_cr("");
+gclog_or_tty->cr();
 }
 #endif
 void CMTask::scan_object(oop obj) {
 assert(_nextMarkBitMap->isMarked((HeapWord*) obj), "invariant");
 if (_cm->verbose_high()) {
 gclog_or_tty->print_cr("[%u] we're scanning object "PTR_FORMAT,
-_worker_id, (void*) obj);
+_worker_id, p2i((void*) obj));
 }
 size_t obj_size = obj->size();
 _words_scanned += obj_size;
 assert(!hr->continuesHumongous(),
 "claim_region() should have filtered out continues humongous regions");
 if (_cm->verbose_low()) {
 gclog_or_tty->print_cr("[%u] setting up for region "PTR_FORMAT,
-_worker_id, hr);
+_worker_id, p2i(hr));
 }
 _curr_region  = hr;
 _finger       = hr->bottom();
 update_region_limit();
 if (limit == bottom) {
 if (_cm->verbose_low()) {
 gclog_or_tty->print_cr("[%u] found an empty region "
 "["PTR_FORMAT", "PTR_FORMAT")",
-_worker_id, bottom, limit);
+_worker_id, p2i(bottom), p2i(limit));
 }
 // The region was collected underneath our feet.
 // We set the finger to bottom to ensure that the bitmap
 // iteration that will follow this will not do anything.
 // (this is not a condition that holds when we set the region up,
 void CMTask::giveup_current_region() {
 assert(_curr_region != NULL, "invariant");
 if (_cm->verbose_low()) {
 gclog_or_tty->print_cr("[%u] giving up region "PTR_FORMAT,
-_worker_id, _curr_region);
+_worker_id, p2i(_curr_region));
 }
 clear_region_fields();
 }
 void CMTask::clear_region_fields() {
 target_size = 0;
 }
 if (_task_queue->size() > target_size) {
 if (_cm->verbose_high()) {
-gclog_or_tty->print_cr("[%u] draining local queue, target size = %d",
+gclog_or_tty->print_cr("[%u] draining local queue, target size = " SIZE_FORMAT,
 _worker_id, target_size);
 }
 oop obj;
 bool ret = _task_queue->pop_local(obj);
 while (ret) {
 statsOnly( ++_local_pops );
 if (_cm->verbose_high()) {
 gclog_or_tty->print_cr("[%u] popped "PTR_FORMAT, _worker_id,
-(void*) obj);
+p2i((void*) obj));
 }
 assert(_g1h->is_in_g1_reserved((HeapWord*) obj), "invariant" );
 assert(!_g1h->is_on_master_free_list(
 _g1h->heap_region_containing((HeapWord*) obj)), "invariant");
 target_size = 0;
 }
 if (_cm->mark_stack_size() > target_size) {
 if (_cm->verbose_low()) {
-gclog_or_tty->print_cr("[%u] draining global_stack, target size %d",
+gclog_or_tty->print_cr("[%u] draining global_stack, target size " SIZE_FORMAT,
 _worker_id, target_size);
 }
 while (!has_aborted() && _cm->mark_stack_size() > target_size) {
 get_entries_from_global_stack();
 drain_local_queue(partially);
 }
 if (_cm->verbose_low()) {
-gclog_or_tty->print_cr("[%u] drained global stack, size = %d",
+gclog_or_tty->print_cr("[%u] drained global stack, size = " SIZE_FORMAT,
 _worker_id, _cm->mark_stack_size());
 }
 }
 }
 if (_cm->verbose_low()) {
 gclog_or_tty->print_cr("[%u] we're scanning part "
 "["PTR_FORMAT", "PTR_FORMAT") "
 "of region "HR_FORMAT,
-_worker_id, _finger, _region_limit,
+_worker_id, p2i(_finger), p2i(_region_limit),
 HR_FORMAT_PARAMS(_curr_region));
 }
 assert(!_curr_region->isHumongous() || mr.start() == _curr_region->bottom(),
 "humongous regions should go around loop once only");
 statsOnly( ++_regions_claimed );
 if (_cm->verbose_low()) {
 gclog_or_tty->print_cr("[%u] we successfully claimed "
 "region "PTR_FORMAT,
-_worker_id, claimed_region);
+_worker_id, p2i(claimed_region));
 }
 setup_for_region(claimed_region);
 assert(_curr_region == claimed_region, "invariant");
 }
 statsOnly( ++_steal_attempts );
 if (_cm->try_stealing(_worker_id, &_hash_seed, obj)) {
 if (_cm->verbose_medium()) {
 gclog_or_tty->print_cr("[%u] stolen "PTR_FORMAT" successfully",
-_worker_id, (void*) obj);
+_worker_id, p2i((void*) obj));
 }
 statsOnly( ++_steals );
 assert(_nextMarkBitMap->isMarked((HeapWord*) obj),
 _out->print_cr(G1PPRL_LINE_PREFIX" PHASE %s @ %1.3f", phase_name, now);
 _out->print_cr(G1PPRL_LINE_PREFIX" HEAP"
 G1PPRL_SUM_ADDR_FORMAT("committed")
 G1PPRL_SUM_ADDR_FORMAT("reserved")
 G1PPRL_SUM_BYTE_FORMAT("region-size"),
-g1_committed.start(), g1_committed.end(),
+p2i(g1_committed.start()), p2i(g1_committed.end()),
-g1_reserved.start(), g1_reserved.end(),
+p2i(g1_reserved.start()), p2i(g1_reserved.end()),
 HeapRegion::GrainBytes);
 _out->print_cr(G1PPRL_LINE_PREFIX);
 _out->print_cr(G1PPRL_LINE_PREFIX
 G1PPRL_TYPE_H_FORMAT
 G1PPRL_ADDR_BASE_H_FORMAT
 G1PPRL_BYTE_FORMAT
 G1PPRL_BYTE_FORMAT
 G1PPRL_DOUBLE_FORMAT
 G1PPRL_BYTE_FORMAT
 G1PPRL_BYTE_FORMAT,
-type, bottom, end,
+type, p2i(bottom), p2i(end),
 used_bytes, prev_live_bytes, next_live_bytes, gc_eff,
 remset_bytes, strong_code_roots_bytes);
 return false;
 }

Mercurial > hg > graal-compiler

comparison src/share/vm/gc_implementation/g1/concurrentMark.cpp @ 18041:52b4284cb496