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

comparison src/share/vm/gc_implementation/g1/heapRegion.cpp @ 1930:2d26b0046e0d

Merge.

author	Thomas Wuerthinger <wuerthinger@ssw.jku.at>
date	Tue, 30 Nov 2010 14:53:30 +0100
parents	0ba67bb5392c 72a161e62cc4
children	06f017f7daa7

comparison

equal deleted inserted replaced

-:6b7001391c97
+:2d26b0046e0d
 /*
-* Copyright 2001-2010 Sun Microsystems, Inc.  All Rights Reserved.
+* Copyright (c) 2001, 2010, 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.
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
-* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
-* CA 95054 USA or visit www.sun.com if you need additional information or
+* or visit www.oracle.com if you need additional information or have any
-* have any questions.
+* questions.
 *
 */
 #include "incls/_precompiled.incl"
 #include "incls/_heapRegion.cpp.incl"
 int region_size_log = log2_long((jlong) region_size);
 // Recalculate the region size to make sure it's a power of
 // 2. This means that region_size is the largest power of 2 that's
 // <= what we've calculated so far.
-region_size = ((uintx)1) << region_size_log;
+region_size = ((uintx)1 << region_size_log);
 // Now make sure that we don't go over or under our limits.
 if (region_size < MIN_REGION_SIZE) {
 region_size = MIN_REGION_SIZE;
 } else if (region_size > MAX_REGION_SIZE) {
 _gc_efficiency = (double) garbage_bytes() /
 g1h->predict_region_elapsed_time_ms(this, false);
 }
 // </PREDICTION>
-void HeapRegion::set_startsHumongous() {
+void HeapRegion::set_startsHumongous(HeapWord* new_end) {
+assert(end() == _orig_end,
+"Should be normal before the humongous object allocation");
+assert(top() == bottom(), "should be empty");
 _humongous_type = StartsHumongous;
 _humongous_start_region = this;
-assert(end() == _orig_end, "Should be normal before alloc.");
+set_end(new_end);
+_offsets.set_for_starts_humongous(new_end);
+}
+void HeapRegion::set_continuesHumongous(HeapRegion* start) {
+assert(end() == _orig_end,
+"Should be normal before the humongous object allocation");
+assert(top() == bottom(), "should be empty");
+assert(start->startsHumongous(), "pre-condition");
+_humongous_type = ContinuesHumongous;
+_humongous_start_region = start;
 }
 bool HeapRegion::claimHeapRegion(jint claimValue) {
 jint current = _claimed;
 if (current != claimValue) {
 NextCompactionHeapRegionClosure blk(r);
 g1h->heap_region_iterate_from(r, &blk);
 return blk.result();
 }
-void HeapRegion::set_continuesHumongous(HeapRegion* start) {
-// The order is important here.
-start->add_continuingHumongousRegion(this);
-_humongous_type = ContinuesHumongous;
-_humongous_start_region = start;
-}
-void HeapRegion::add_continuingHumongousRegion(HeapRegion* cont) {
-// Must join the blocks of the current H region seq with the block of the
-// added region.
-offsets()->join_blocks(bottom(), cont->bottom());
-arrayOop obj = (arrayOop)(bottom());
-obj->set_length((int) (obj->length() + cont->capacity()/jintSize));
-set_end(cont->end());
-set_top(cont->end());
-}
 void HeapRegion::save_marks() {
 set_saved_mark();
 }
 void HeapRegion::oops_in_mr_iterate(MemRegion mr, OopClosure* cl) {
 return G1OffsetTableContigSpace::allocate(size);
 }
 #endif
 void HeapRegion::set_zero_fill_state_work(ZeroFillState zfs) {
-assert(top() == bottom() || zfs == Allocated,
-"Region must be empty, or we must be setting it to allocated.");
 assert(ZF_mon->owned_by_self() ||
 Universe::heap()->is_gc_active(),
 "Must hold the lock or be a full GC to modify.");
+#ifdef ASSERT
+if (top() != bottom() && zfs != Allocated) {
+ResourceMark rm;
+stringStream region_str;
+print_on(&region_str);
+assert(top() == bottom() || zfs == Allocated,
+err_msg("Region must be empty, or we must be setting it to allocated. "
+"_zfs=%d, zfs=%d, region: %s", _zfs, zfs, region_str.as_string()));
+}
+#endif
 _zfs = zfs;
 }
 void HeapRegion::set_zero_fill_complete() {
 set_zero_fill_state_work(ZeroFilled);
 }
 HeapWord*
 HeapRegion::
 oops_on_card_seq_iterate_careful(MemRegion mr,
-FilterOutOfRegionClosure* cl) {
+FilterOutOfRegionClosure* cl,
+bool filter_young) {
 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.
 } else {
 mr = mr.intersection(used_region());
 }
 if (mr.is_empty()) return NULL;
 // Otherwise, find the obj that extends onto mr.start().
+// The intersection of the incoming mr (for the card) and the
+// allocated part of the region is non-empty. This implies that
+// we have actually allocated into this region. The code in
+// G1CollectedHeap.cpp that allocates a new region sets the
+// is_young tag on the region before allocating. Thus we
+// safely know if this region is young.
+if (is_young() && filter_young) {
+return NULL;
+}
+assert(!is_young(), "check value of filter_young");
 // 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());
 assert(cur <= mr.start(), "Postcondition");
 HeapWord* p = bottom();
 HeapWord* prev_p = NULL;
 int objs = 0;
 int blocks = 0;
 VerifyLiveClosure vl_cl(g1, use_prev_marking);
+bool is_humongous = isHumongous();
+size_t object_num = 0;
 while (p < top()) {
 size_t size = oop(p)->size();
+if (is_humongous != g1->isHumongous(size)) {
+gclog_or_tty->print_cr("obj "PTR_FORMAT" is of %shumongous size ("
+SIZE_FORMAT" words) in a %shumongous region",
+p, g1->isHumongous(size) ? "" : "non-",
+size, is_humongous ? "" : "non-");
+*failures = true;
+}
+object_num += 1;
 if (blocks == BLOCK_SAMPLE_INTERVAL) {
 HeapWord* res = block_start_const(p + (size/2));
 if (p != res) {
 gclog_or_tty->print_cr("offset computation 1 for "PTR_FORMAT" and "
 SIZE_FORMAT" returned "PTR_FORMAT,
 *failures = true;
 return;
 }
 }
+if (is_humongous && object_num > 1) {
+gclog_or_tty->print_cr("region ["PTR_FORMAT","PTR_FORMAT"] is humongous "
+"but has "SIZE_FORMAT", objects",
+bottom(), end(), object_num);
+*failures = true;
+}
 if (p != top()) {
 gclog_or_tty->print_cr("end of last object "PTR_FORMAT" "
 "does not match top "PTR_FORMAT, p, top());
 *failures = true;
 return;

Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/heapRegion.cpp @ 1930:2d26b0046e0d