truffle: src/share/vm/gc_implementation/g1/heapRegion.cpp comparison

comparison src/share/vm/gc_implementation/g1/heapRegion.cpp @ 4970:33df1aeaebbf

Merge with http://hg.openjdk.java.net/hsx/hsx24/hotspot/

author	Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
date	Mon, 27 Feb 2012 13:10:13 +0100
parents	04b9a2566eec a9647476d1a4
children	957c266d8bc5

comparison

equal deleted inserted replaced

-:2cfb7fb2dce7
+:33df1aeaebbf
 /*
-* Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2001, 2012, 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.
 #else // PRODUCT
 obj->print_on(out);
 #endif // PRODUCT
 }
-template <class T> void do_oop_work(T* p) {
+template <class T>
+void do_oop_work(T* p) {
 assert(_containing_obj != NULL, "Precondition");
 assert(!_g1h->is_obj_dead_cond(_containing_obj, _vo),
 "Precondition");
 T heap_oop = oopDesc::load_heap_oop(p);
 if (!oopDesc::is_null(heap_oop)) {
 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
 bool failed = false;
-if (!_g1h->is_in_closed_subset(obj) ||
+if (!_g1h->is_in_closed_subset(obj) || _g1h->is_obj_dead_cond(obj, _vo)) {
-_g1h->is_obj_dead_cond(obj, _vo)) {
+MutexLockerEx x(ParGCRareEvent_lock,
+Mutex::_no_safepoint_check_flag);
 if (!_failures) {
 gclog_or_tty->print_cr("");
 gclog_or_tty->print_cr("----------");
 }
 if (!_g1h->is_in_closed_subset(obj)) {
 "["PTR_FORMAT", "PTR_FORMAT")",
 (void*) obj, to->bottom(), to->end());
 print_object(gclog_or_tty, obj);
 }
 gclog_or_tty->print_cr("----------");
+gclog_or_tty->flush();
 _failures = true;
 failed = true;
 _n_failures++;
 }
 || !G1HRRSFlushLogBuffersOnVerify && // buffers were not flushed
 (_containing_obj->is_objArray() ?
 cv_field == dirty
 : cv_obj == dirty || cv_field == dirty));
 if (is_bad) {
+MutexLockerEx x(ParGCRareEvent_lock,
+Mutex::_no_safepoint_check_flag);
 if (!_failures) {
 gclog_or_tty->print_cr("");
 gclog_or_tty->print_cr("----------");
 }
 gclog_or_tty->print_cr("Missing rem set entry:");
 HR_FORMAT_PARAMS(to));
 obj->print_on(gclog_or_tty);
 gclog_or_tty->print_cr("Obj head CTE = %d, field CTE = %d.",
 cv_obj, cv_field);
 gclog_or_tty->print_cr("----------");
+gclog_or_tty->flush();
 _failures = true;
 if (!failed) _n_failures++;
 }
 }
 }
 CardTableModRefBS* ct_bs =
 (CardTableModRefBS*)G1CollectedHeap::heap()->barrier_set();
 ct_bs->clear(MemRegion(bottom(), end()));
 }
-// <PREDICTION>
 void HeapRegion::calc_gc_efficiency() {
 G1CollectedHeap* g1h = G1CollectedHeap::heap();
-_gc_efficiency = (double) garbage_bytes() /
+G1CollectorPolicy* g1p = g1h->g1_policy();
-g1h->predict_region_elapsed_time_ms(this, false);
+_gc_efficiency = (double) reclaimable_bytes() /
-}
+g1p->predict_region_elapsed_time_ms(this, false);
-// </PREDICTION>
+}
 void HeapRegion::set_startsHumongous(HeapWord* new_top, HeapWord* new_end) {
 assert(!isHumongous(), "sanity / pre-condition");
 assert(end() == _orig_end,
 "Should be normal before the humongous object allocation");
 void HeapRegion::oop_before_save_marks_iterate(OopClosure* cl) {
 oops_in_mr_iterate(MemRegion(bottom(), saved_mark_word()), cl);
 }
+void HeapRegion::note_self_forwarding_removal_start(bool during_initial_mark,
+bool during_conc_mark) {
+// We always recreate the prev marking info and we'll explicitly
+// mark all objects we find to be self-forwarded on the prev
+// bitmap. So all objects need to be below PTAMS.
+_prev_top_at_mark_start = top();
+_prev_marked_bytes = 0;
+if (during_initial_mark) {
+// During initial-mark, we'll also explicitly mark all objects
+// we find to be self-forwarded on the next bitmap. So all
+// objects need to be below NTAMS.
+_next_top_at_mark_start = top();
+set_top_at_conc_mark_count(bottom());
+_next_marked_bytes = 0;
+} else if (during_conc_mark) {
+// During concurrent mark, all objects in the CSet (including
+// the ones we find to be self-forwarded) are implicitly live.
+// So all objects need to be above NTAMS.
+_next_top_at_mark_start = bottom();
+set_top_at_conc_mark_count(bottom());
+_next_marked_bytes = 0;
+}
+}
+void HeapRegion::note_self_forwarding_removal_end(bool during_initial_mark,
+bool during_conc_mark,
+size_t marked_bytes) {
+assert(0 <= marked_bytes && marked_bytes <= used(),
+err_msg("marked: "SIZE_FORMAT" used: "SIZE_FORMAT,
+marked_bytes, used()));
+_prev_marked_bytes = marked_bytes;
+}
 HeapWord*
 HeapRegion::object_iterate_mem_careful(MemRegion mr,
 ObjectClosure* cl) {
 G1CollectedHeap* g1h = G1CollectedHeap::heap();
 // We used to use "block_start_careful" here.  But we're actually happy
 G1CollectedHeap* g1h = G1CollectedHeap::heap();
 // If we're within a stop-world GC, then we might look at a card in a
 // GC alloc region that extends onto a GC LAB, which may not be
 // parseable.  Stop such at the "saved_mark" of the region.
-if (G1CollectedHeap::heap()->is_gc_active()) {
+if (g1h->is_gc_active()) {
 mr = mr.intersection(used_region_at_save_marks());
 } else {
 mr = mr.intersection(used_region());
 }
 if (mr.is_empty()) return NULL;
 *card_ptr = CardTableModRefBS::clean_card_val();
 // We must complete this write before we do any of the reads below.
 OrderAccess::storeload();
 }
+// Cache the boundaries of the memory region in some const locals
+HeapWord* const start = mr.start();
+HeapWord* const end = mr.end();
 // We used to use "block_start_careful" here.  But we're actually happy
 // to update the BOT while we do this...
-HeapWord* cur = block_start(mr.start());
+HeapWord* cur = block_start(start);
-assert(cur <= mr.start(), "Postcondition");
+assert(cur <= start, "Postcondition");
-while (cur <= mr.start()) {
+oop obj;
-if (oop(cur)->klass_or_null() == NULL) {
+HeapWord* next = cur;
+while (next <= start) {
+cur = next;
+obj = oop(cur);
+if (obj->klass_or_null() == NULL) {
 // Ran into an unparseable point.
 return cur;
 }
 // Otherwise...
-int sz = oop(cur)->size();
+next = (cur + obj->size());
-if (cur + sz > mr.start()) break;
+}
-// Otherwise, go on.
-cur = cur + sz;
+// If we finish the above loop...We have a parseable object that
-}
+// begins on or before the start of the memory region, and ends
-oop obj;
+// inside or spans the entire region.
-obj = oop(cur);
-// If we finish this loop...
+assert(obj == oop(cur), "sanity");
-assert(cur <= mr.start()
+assert(cur <= start &&
-&& obj->klass_or_null() != NULL
+obj->klass_or_null() != NULL &&
-&& cur + obj->size() > mr.start(),
+(cur + obj->size()) > start,
 "Loop postcondition");
 if (!g1h->is_obj_dead(obj)) {
 obj->oop_iterate(cl, mr);
 }
-HeapWord* next;
+while (cur < end) {
-while (cur < mr.end()) {
 obj = oop(cur);
 if (obj->klass_or_null() == NULL) {
 // Ran into an unparseable point.
 return cur;
 };
 // Otherwise:
 next = (cur + obj->size());
 if (!g1h->is_obj_dead(obj)) {
-if (next < mr.end()) {
+if (next < end || !obj->is_objArray()) {
+// This object either does not span the MemRegion
+// boundary, or if it does it's not an array.
+// Apply closure to whole object.
 obj->oop_iterate(cl);
 } else {
-// this obj spans the boundary.  If it's an array, stop at the
+// This obj is an array that spans the boundary.
-// boundary.
+// Stop at the boundary.
-if (obj->is_objArray()) {
+obj->oop_iterate(cl, mr);
-obj->oop_iterate(cl, mr);
-} else {
-obj->oop_iterate(cl);
-}
 }
 }
 cur = next;
 }
 return NULL;

Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/heapRegion.cpp @ 4970:33df1aeaebbf