jdk8-mips64-public/hotspot: comparison src/share/vm/gc_implementation/g1/concurrentG1Refine.cpp

-:5c0b591e1074
+:02f49b66361a
 #include "gc_implementation/g1/g1CollectorPolicy.hpp"
 #include "gc_implementation/g1/g1RemSet.hpp"
 #include "gc_implementation/g1/heapRegionSeq.inline.hpp"
 #include "memory/space.inline.hpp"
 #include "runtime/atomic.hpp"
+#include "runtime/java.hpp"
 #include "utilities/copy.hpp"
 // Possible sizes for the card counts cache: odd primes that roughly double in size.
 // (See jvmtiTagMap.cpp).
-int ConcurrentG1Refine::_cc_cache_sizes[] = {
-16381,    32771,    76831,    150001,   307261,
+#define MAX_SIZE ((size_t) -1)
-614563,  1228891,  2457733,   4915219,  9830479,
-19660831, 39321619, 78643219, 157286461,       -1
+size_t ConcurrentG1Refine::_cc_cache_sizes[] = {
+16381,    32771,    76831,    150001,   307261,
+614563,  1228891,  2457733,   4915219,  9830479,
+19660831, 39321619, 78643219, 157286461,  MAX_SIZE
 };
 ConcurrentG1Refine::ConcurrentG1Refine() :
 _card_counts(NULL), _card_epochs(NULL),
-_n_card_counts(0), _max_n_card_counts(0),
+_n_card_counts(0), _max_cards(0), _max_n_card_counts(0),
 _cache_size_index(0), _expand_card_counts(false),
 _hot_cache(NULL),
 _def_use_cache(false), _use_cache(false),
 _n_periods(0),
 _threads(NULL), _n_threads(0)
 }
 void ConcurrentG1Refine::init() {
 if (G1ConcRSLogCacheSize > 0) {
 _g1h = G1CollectedHeap::heap();
-_max_n_card_counts =
-(unsigned) (_g1h->max_capacity() >> CardTableModRefBS::card_shift);
+_max_cards = _g1h->max_capacity() >> CardTableModRefBS::card_shift;
+_max_n_card_counts = _max_cards * G1MaxHotCardCountSizePercent / 100;
 size_t max_card_num = ((size_t)1 << (sizeof(unsigned)*BitsPerByte-1)) - 1;
-guarantee(_max_n_card_counts < max_card_num, "card_num representation");
+guarantee(_max_cards < max_card_num, "card_num representation");
-int desired = _max_n_card_counts / InitialCacheFraction;
+// We need _n_card_counts to be less than _max_n_card_counts here
-for (_cache_size_index = 0;
+// so that the expansion call (below) actually allocates the
-_cc_cache_sizes[_cache_size_index] >= 0; _cache_size_index++) {
+// _counts and _epochs arrays.
-if (_cc_cache_sizes[_cache_size_index] >= desired) break;
+assert(_n_card_counts == 0, "pre-condition");
-}
+assert(_max_n_card_counts > 0, "pre-condition");
-_cache_size_index = MAX2(0, (_cache_size_index - 1));
+// Find the index into cache size array that is of a size that's
-int initial_size = _cc_cache_sizes[_cache_size_index];
+// large enough to hold desired_sz.
-if (initial_size < 0) initial_size = _max_n_card_counts;
+size_t desired_sz = _max_cards / InitialCacheFraction;
+int desired_sz_index = 0;
-// Make sure we don't go bigger than we will ever need
+while (_cc_cache_sizes[desired_sz_index] < desired_sz) {
-_n_card_counts = MIN2((unsigned) initial_size, _max_n_card_counts);
+desired_sz_index += 1;
+assert(desired_sz_index <  MAX_CC_CACHE_INDEX, "invariant");
-_card_counts = NEW_C_HEAP_ARRAY(CardCountCacheEntry, _n_card_counts);
+}
-_card_epochs = NEW_C_HEAP_ARRAY(CardEpochCacheEntry, _n_card_counts);
+assert(desired_sz_index <  MAX_CC_CACHE_INDEX, "invariant");
+// If the desired_sz value is between two sizes then
+// _cc_cache_sizes[desired_sz_index-1] < desired_sz <= _cc_cache_sizes[desired_sz_index]
+// we will start with the lower size in the optimistic expectation that
+// we will not need to expand up. Note desired_sz_index could also be 0.
+if (desired_sz_index > 0 &&
+_cc_cache_sizes[desired_sz_index] > desired_sz) {
+desired_sz_index -= 1;
+}
+if (!expand_card_count_cache(desired_sz_index)) {
+// Allocation was unsuccessful - exit
+vm_exit_during_initialization("Could not reserve enough space for card count cache");
+}
+assert(_n_card_counts > 0, "post-condition");
+assert(_cache_size_index == desired_sz_index, "post-condition");
 Copy::fill_to_bytes(&_card_counts[0],
 _n_card_counts * sizeof(CardCountCacheEntry));
 Copy::fill_to_bytes(&_card_epochs[0], _n_card_counts * sizeof(CardEpochCacheEntry));
 }
 }
 ConcurrentG1Refine::~ConcurrentG1Refine() {
 if (G1ConcRSLogCacheSize > 0) {
+// Please see the comment in allocate_card_count_cache
+// for why we call os::malloc() and os::free() directly.
 assert(_card_counts != NULL, "Logic");
-FREE_C_HEAP_ARRAY(CardCountCacheEntry, _card_counts);
+os::free(_card_counts);
 assert(_card_epochs != NULL, "Logic");
-FREE_C_HEAP_ARRAY(CardEpochCacheEntry, _card_epochs);
+os::free(_card_epochs);
 assert(_hot_cache != NULL, "Logic");
 FREE_C_HEAP_ARRAY(jbyte*, _hot_cache);
 }
 if (_threads != NULL) {
 for (int i = 0; i < _n_threads; i++) {
 }
 }
 }
 }
-void ConcurrentG1Refine::expand_card_count_cache() {
+// The arrays used to hold the card counts and the epochs must have
+// a 1:1 correspondence. Hence they are allocated and freed together
+// Returns true if the allocations of both the counts and epochs
+// were successful; false otherwise.
+bool ConcurrentG1Refine::allocate_card_count_cache(size_t n,
+CardCountCacheEntry** counts,
+CardEpochCacheEntry** epochs) {
+// We call the allocation/free routines directly for the counts
+// and epochs arrays. The NEW_C_HEAP_ARRAY/FREE_C_HEAP_ARRAY
+// macros call AllocateHeap and FreeHeap respectively.
+// AllocateHeap will call vm_exit_out_of_memory in the event
+// of an allocation failure and abort the JVM. With the
+// _counts/epochs arrays we only need to abort the JVM if the
+// initial allocation of these arrays fails.
+//
+// Additionally AllocateHeap/FreeHeap do some tracing of
+// allocate/free calls so calling one without calling the
+// other can cause inconsistencies in the tracing. So we
+// call neither.
+assert(*counts == NULL, "out param");
+assert(*epochs == NULL, "out param");
+size_t counts_size = n * sizeof(CardCountCacheEntry);
+size_t epochs_size = n * sizeof(CardEpochCacheEntry);
+*counts = (CardCountCacheEntry*) os::malloc(counts_size);
+if (*counts == NULL) {
+// allocation was unsuccessful
+return false;
+}
+*epochs = (CardEpochCacheEntry*) os::malloc(epochs_size);
+if (*epochs == NULL) {
+// allocation was unsuccessful - free counts array
+assert(*counts != NULL, "must be");
+os::free(*counts);
+*counts = NULL;
+return false;
+}
+// We successfully allocated both counts and epochs
+return true;
+}
+// Returns true if the card counts/epochs cache was
+// successfully expanded; false otherwise.
+bool ConcurrentG1Refine::expand_card_count_cache(int cache_size_idx) {
+// Can we expand the card count and epoch tables?
 if (_n_card_counts < _max_n_card_counts) {
-int new_idx = _cache_size_index+1;
+assert(cache_size_idx >= 0 && cache_size_idx  < MAX_CC_CACHE_INDEX, "oob");
-int new_size = _cc_cache_sizes[new_idx];
-if (new_size < 0) new_size = _max_n_card_counts;
+size_t cache_size = _cc_cache_sizes[cache_size_idx];
 // Make sure we don't go bigger than we will ever need
-new_size = MIN2((unsigned) new_size, _max_n_card_counts);
+cache_size = MIN2(cache_size, _max_n_card_counts);
-// Expand the card count and card epoch tables
+// Should we expand the card count and card epoch tables?
-if (new_size > (int)_n_card_counts) {
+if (cache_size > _n_card_counts) {
-// We can just free and allocate a new array as we're
+// We have been asked to allocate new, larger, arrays for
-// not interested in preserving the contents
+// the card counts and the epochs. Attempt the allocation
-assert(_card_counts != NULL, "Logic!");
+// of both before we free the existing arrays in case
-assert(_card_epochs != NULL, "Logic!");
+// the allocation is unsuccessful...
-FREE_C_HEAP_ARRAY(CardCountCacheEntry, _card_counts);
+CardCountCacheEntry* counts = NULL;
-FREE_C_HEAP_ARRAY(CardEpochCacheEntry, _card_epochs);
+CardEpochCacheEntry* epochs = NULL;
-_n_card_counts = new_size;
-_card_counts = NEW_C_HEAP_ARRAY(CardCountCacheEntry, _n_card_counts);
+if (allocate_card_count_cache(cache_size, &counts, &epochs)) {
-_card_epochs = NEW_C_HEAP_ARRAY(CardEpochCacheEntry, _n_card_counts);
+// Allocation was successful.
-_cache_size_index = new_idx;
+// We can just free the old arrays; we're
-}
+// not interested in preserving the contents
-}
+if (_card_counts != NULL) os::free(_card_counts);
+if (_card_epochs != NULL) os::free(_card_epochs);
+// Cache the size of the arrays and the index that got us there.
+_n_card_counts = cache_size;
+_cache_size_index = cache_size_idx;
+_card_counts = counts;
+_card_epochs = epochs;
+// We successfully allocated/expanded the caches.
+return true;
+}
+}
+}
+// We did not successfully expand the caches.
+return false;
 }
 void ConcurrentG1Refine::clear_and_record_card_counts() {
 if (G1ConcRSLogCacheSize == 0) return;
 #ifndef PRODUCT
 double start = os::elapsedTime();
 #endif
 if (_expand_card_counts) {
-expand_card_count_cache();
+int new_idx = _cache_size_index + 1;
+if (expand_card_count_cache(new_idx)) {
+// Allocation was successful and  _n_card_counts has
+// been updated to the new size. We only need to clear
+// the epochs so we don't read a bogus epoch value
+// when inserting a card into the hot card cache.
+Copy::fill_to_bytes(&_card_epochs[0], _n_card_counts * sizeof(CardEpochCacheEntry));
+}
 _expand_card_counts = false;
-// Only need to clear the epochs.
-Copy::fill_to_bytes(&_card_epochs[0], _n_card_counts * sizeof(CardEpochCacheEntry));
 }
 int this_epoch = (int) _n_periods;
 assert((this_epoch+1) <= max_jint, "to many periods");
 // Update epoch

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/gc_implementation/g1/concurrentG1Refine.cpp

src/share/vm/gc_implementation/g1/concurrentG1Refine.cpp