graal-jvmci-8: src/share/vm/memory/blockOffsetTable.cpp comparison

comparison src/share/vm/memory/blockOffsetTable.cpp @ 1716:be3f9c242c9d

6948538: CMS: BOT walkers can fall into object allocation and initialization cracks Summary: GC workers now recognize an intermediate transient state of blocks which are allocated but have not yet completed initialization. blk_start() calls do not attempt to determine the size of a block in the transient state, rather waiting for the block to become initialized so that it is safe to query its size. Audited and ensured the order of initialization of object fields (klass, free bit and size) to respect block state transition protocol. Also included some new assertion checking code enabled in debug mode. Reviewed-by: chrisphi, johnc, poonam

author	ysr
date	Mon, 16 Aug 2010 15:58:42 -0700
parents	c18cbe5936b8
children	f95d63e2154a

comparison

equal deleted inserted replaced

-:7fcd5f39bd7a
+:be3f9c242c9d
 /*
-* Copyright (c) 2000, 2006, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2000, 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.
 //////////////////////////////////////////////////////////////////////
 // BlockOffsetArray
 //////////////////////////////////////////////////////////////////////
 BlockOffsetArray::BlockOffsetArray(BlockOffsetSharedArray* array,
-MemRegion mr, bool init_to_zero) :
+MemRegion mr, bool init_to_zero_) :
 BlockOffsetTable(mr.start(), mr.end()),
-_array(array),
+_array(array)
-_init_to_zero(init_to_zero)
 {
 assert(_bottom <= _end, "arguments out of order");
-if (!_init_to_zero) {
+set_init_to_zero(init_to_zero_);
+if (!init_to_zero_) {
 // initialize cards to point back to mr.start()
 set_remainder_to_point_to_start(mr.start() + N_words, mr.end());
 _array->set_offset_array(0, 0);  // set first card to 0
 }
 }
 // The arguments follow the normal convention of denoting
 // a right-open interval: [start, end)
 void
 BlockOffsetArray::
-set_remainder_to_point_to_start(HeapWord* start, HeapWord* end) {
+set_remainder_to_point_to_start(HeapWord* start, HeapWord* end, bool reducing) {
+check_reducing_assertion(reducing);
 if (start >= end) {
 // The start address is equal to the end address (or to
 // the right of the end address) so there are not cards
 // that need to be updated..
 return;
 //
 size_t start_card = _array->index_for(start);
 size_t end_card = _array->index_for(end-1);
 assert(start ==_array->address_for_index(start_card), "Precondition");
 assert(end ==_array->address_for_index(end_card)+N_words, "Precondition");
-set_remainder_to_point_to_start_incl(start_card, end_card); // closed interval
+set_remainder_to_point_to_start_incl(start_card, end_card, reducing); // closed interval
 }
 // Unlike the normal convention in this code, the argument here denotes
 // a closed, inclusive interval: [start_card, end_card], cf set_remainder_to_point_to_start()
 // above.
 void
-BlockOffsetArray::set_remainder_to_point_to_start_incl(size_t start_card, size_t end_card) {
+BlockOffsetArray::set_remainder_to_point_to_start_incl(size_t start_card, size_t end_card, bool reducing) {
+check_reducing_assertion(reducing);
 if (start_card > end_card) {
 return;
 }
 assert(start_card > _array->index_for(_bottom), "Cannot be first card");
 assert(_array->offset_array(start_card-1) <= N_words,
 // so that the reach ends in this region and not at the start
 // of the next.
 size_t reach = start_card - 1 + (power_to_cards_back(i+1) - 1);
 offset = N_words + i;
 if (reach >= end_card) {
-_array->set_offset_array(start_card_for_region, end_card, offset);
+_array->set_offset_array(start_card_for_region, end_card, offset, reducing);
 start_card_for_region = reach + 1;
 break;
 }
-_array->set_offset_array(start_card_for_region, reach, offset);
+_array->set_offset_array(start_card_for_region, reach, offset, reducing);
 start_card_for_region = reach + 1;
 }
 assert(start_card_for_region > end_card, "Sanity check");
 DEBUG_ONLY(check_all_cards(start_card, end_card);)
 }
 if (end_card < start_card) {
 return;
 }
 guarantee(_array->offset_array(start_card) == N_words, "Wrong value in second card");
+u_char last_entry = N_words;
 for (size_t c = start_card + 1; c <= end_card; c++ /* yeah! */) {
 u_char entry = _array->offset_array(c);
+guarantee(entry >= last_entry, "Monotonicity");
 if (c - start_card > power_to_cards_back(1)) {
 guarantee(entry > N_words, "Should be in logarithmic region");
 }
 size_t backskip = entry_to_cards_back(entry);
 size_t landing_card = c - backskip;
 guarantee(landing_card >= (start_card - 1), "Inv");
 if (landing_card >= start_card) {
-guarantee(_array->offset_array(landing_card) <= entry, "monotonicity");
+guarantee(_array->offset_array(landing_card) <= entry, "Monotonicity");
 } else {
-guarantee(landing_card == start_card - 1, "Tautology");
+guarantee(landing_card == (start_card - 1), "Tautology");
+// Note that N_words is the maximum offset value
 guarantee(_array->offset_array(landing_card) <= N_words, "Offset value");
 }
+last_entry = entry;  // remember for monotonicity test
 }
 }
 void
 // Action_single - udpate the BOT for an allocation.
 // Action_verify - BOT verification.
 void
 BlockOffsetArray::do_block_internal(HeapWord* blk_start,
 HeapWord* blk_end,
-Action action) {
+Action action, bool reducing) {
 assert(Universe::heap()->is_in_reserved(blk_start),
 "reference must be into the heap");
 assert(Universe::heap()->is_in_reserved(blk_end-1),
 "limit must be within the heap");
 // This is optimized to make the test fast, assuming we only rarely
 assert(start_index <= end_index, "monotonicity of index_for()");
 assert(boundary <= (HeapWord*)boundary_before_end, "tautology");
 switch (action) {
 case Action_mark: {
 if (init_to_zero()) {
-_array->set_offset_array(start_index, boundary, blk_start);
+_array->set_offset_array(start_index, boundary, blk_start, reducing);
 break;
 } // Else fall through to the next case
 }
 case Action_single: {
-_array->set_offset_array(start_index, boundary, blk_start);
+_array->set_offset_array(start_index, boundary, blk_start, reducing);
 // We have finished marking the "offset card". We need to now
 // mark the subsequent cards that this blk spans.
 if (start_index < end_index) {
 HeapWord* rem_st = _array->address_for_index(start_index) + N_words;
 HeapWord* rem_end = _array->address_for_index(end_index) + N_words;
-set_remainder_to_point_to_start(rem_st, rem_end);
+set_remainder_to_point_to_start(rem_st, rem_end, reducing);
 }
 break;
 }
 case Action_check: {
 _array->check_offset_array(start_index, boundary, blk_start);
 HeapWord* end_addr  = blk + blk_size;
 // Indices for starts of prefix block and suffix block.
 size_t pref_index = _array->index_for(pref_addr);
 if (_array->address_for_index(pref_index) != pref_addr) {
-// pref_addr deos not begin pref_index
+// pref_addr does not begin pref_index
 pref_index++;
 }
 size_t suff_index = _array->index_for(suff_addr);
 if (_array->address_for_index(suff_index) != suff_addr) {
 size_t num_suff_cards = end_index  - suff_index;
 // Change the cards that need changing
 if (num_suff_cards > 0) {
 HeapWord* boundary = _array->address_for_index(suff_index);
 // Set the offset card for suffix block
-_array->set_offset_array(suff_index, boundary, suff_addr);
+_array->set_offset_array(suff_index, boundary, suff_addr, true /* reducing */);
 // Change any further cards that need changing in the suffix
 if (num_pref_cards > 0) {
 if (num_pref_cards >= num_suff_cards) {
 // Unilaterally fix all of the suffix cards: closed card
 // index interval in args below.
-set_remainder_to_point_to_start_incl(suff_index + 1, end_index - 1);
+set_remainder_to_point_to_start_incl(suff_index + 1, end_index - 1, true /* reducing */);
 } else {
 // Unilaterally fix the first (num_pref_cards - 1) following
 // the "offset card" in the suffix block.
 set_remainder_to_point_to_start_incl(suff_index + 1,
-suff_index + num_pref_cards - 1);
+suff_index + num_pref_cards - 1, true /* reducing */);
 // Fix the appropriate cards in the remainder of the
 // suffix block -- these are the last num_pref_cards
 // cards in each power block of the "new" range plumbed
 // from suff_addr.
 bool more = true;
 if (back_by > num_pref_cards) {
 // Fill in the remainder of this "power block", if it
 // is non-null.
 if (left_index <= right_index) {
 _array->set_offset_array(left_index, right_index,
-N_words + i - 1);
+N_words + i - 1, true /* reducing */);
 } else {
 more = false; // we are done
 }
 i++;
 break;
 break;
 }
 more  = false;
 }
 assert(left_index <= right_index, "Error");
-_array->set_offset_array(left_index, right_index, N_words + i - 1);
+_array->set_offset_array(left_index, right_index, N_words + i - 1, true /* reducing */);
 i++;
 }
 }
 } // else no more cards to fix in suffix
 } // else nothing needs to be done
 // with the appropriate offset.
 // NOTE: this method does _not_ adjust _unallocated_block or
 // any cards subsequent to the first one.
 void
 BlockOffsetArrayNonContigSpace::mark_block(HeapWord* blk_start,
-HeapWord* blk_end) {
+HeapWord* blk_end, bool reducing) {
-do_block_internal(blk_start, blk_end, Action_mark);
+do_block_internal(blk_start, blk_end, Action_mark, reducing);
 }
 HeapWord* BlockOffsetArrayNonContigSpace::block_start_unsafe(
 const void* addr) const {
 assert(_array->offset_array(0) == 0, "objects can't cross covered areas");
 assert(_bottom <= addr && addr < _end,
 "addr must be covered by this Array");
 // Must read this exactly once because it can be modified by parallel
 // allocation.
 HeapWord* ub = _unallocated_block;
 while (n <= addr) {
 debug_only(HeapWord* last = q);   // for debugging
 q = n;
 n += _sp->block_size(n);
-}
+assert(n > q, err_msg("Looping at: " INTPTR_FORMAT, n));
-assert(q <= addr, "wrong order for current and arg");
+}
-assert(addr <= n, "wrong order for arg and next");
+assert(q <= addr, err_msg("wrong order for current (" INTPTR_FORMAT ") <= arg (" INTPTR_FORMAT ")", q, addr));
+assert(addr <= n, err_msg("wrong order for arg (" INTPTR_FORMAT ") <= next (" INTPTR_FORMAT ")", addr, n));
 return q;
 }
 HeapWord* BlockOffsetArrayNonContigSpace::block_start_careful(
 const void* addr) const {
 // _next_offset_index and _next_offset_threshold updated here.
 _next_offset_index = end_index + 1;
 // Calculate _next_offset_threshold this way because end_index
 // may be the last valid index in the covered region.
-_next_offset_threshold = _array->address_for_index(end_index) +
+_next_offset_threshold = _array->address_for_index(end_index) + N_words;
-N_words;
+assert(_next_offset_threshold >= blk_end, "Incorrect offset threshold");
-assert(_next_offset_threshold >= blk_end, "Incorrent offset threshold");
 #ifdef ASSERT
 // The offset can be 0 if the block starts on a boundary.  That
 // is checked by an assertion above.
 size_t start_index = _array->index_for(blk_start);

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/memory/blockOffsetTable.cpp @ 1716:be3f9c242c9d