--- a/hotspot/src/share/vm/gc_implementation/g1/collectionSetChooser.hpp Wed Apr 18 07:21:15 2012 -0400
+++ b/hotspot/src/share/vm/gc_implementation/g1/collectionSetChooser.hpp Wed Apr 18 13:39:55 2012 -0400
@@ -28,77 +28,42 @@
#include "gc_implementation/g1/heapRegion.hpp"
#include "utilities/growableArray.hpp"
-class CSetChooserCache VALUE_OBJ_CLASS_SPEC {
-private:
- enum {
- CacheLength = 16
- } PrivateConstants;
-
- HeapRegion* _cache[CacheLength];
- int _occupancy; // number of regions in cache
- int _first; // (index of) "first" region in the cache
-
- // adding CacheLength to deal with negative values
- inline int trim_index(int index) {
- return (index + CacheLength) % CacheLength;
- }
-
- inline int get_sort_index(int index) {
- return -index-2;
- }
- inline int get_index(int sort_index) {
- return -sort_index-2;
- }
-
-public:
- CSetChooserCache(void);
-
- inline int occupancy(void) { return _occupancy; }
- inline bool is_full() { return _occupancy == CacheLength; }
- inline bool is_empty() { return _occupancy == 0; }
-
- void clear(void);
- void insert(HeapRegion *hr);
- HeapRegion *remove_first(void);
- inline HeapRegion *get_first(void) {
- return _cache[_first];
- }
-
-#ifndef PRODUCT
- bool verify (void);
- bool region_in_cache(HeapRegion *hr) {
- int sort_index = hr->sort_index();
- if (sort_index < -1) {
- int index = get_index(sort_index);
- guarantee(index < CacheLength, "should be within bounds");
- return _cache[index] == hr;
- } else
- return 0;
- }
-#endif // PRODUCT
-};
-
class CollectionSetChooser: public CHeapObj {
- GrowableArray<HeapRegion*> _markedRegions;
+ GrowableArray<HeapRegion*> _regions;
+
+ // Unfortunately, GrowableArray uses ints for length and indexes. To
+ // avoid excessive casting in the rest of the class the following
+ // wrapper methods are provided that use uints.
+
+ uint regions_length() { return (uint) _regions.length(); }
+ HeapRegion* regions_at(uint i) { return _regions.at((int) i); }
+ void regions_at_put(uint i, HeapRegion* hr) {
+ _regions.at_put((int) i, hr);
+ }
+ void regions_at_put_grow(uint i, HeapRegion* hr) {
+ _regions.at_put_grow((int) i, hr);
+ }
+ void regions_trunc_to(uint i) { _regions.trunc_to((uint) i); }
// The index of the next candidate old region to be considered for
// addition to the CSet.
- int _curr_index;
+ uint _curr_index;
// The number of candidate old regions added to the CSet chooser.
- int _length;
+ uint _length;
- CSetChooserCache _cache;
- jint _first_par_unreserved_idx;
+ // Keeps track of the start of the next array chunk to be claimed by
+ // parallel GC workers.
+ uint _first_par_unreserved_idx;
// If a region has more live bytes than this threshold, it will not
// be added to the CSet chooser and will not be a candidate for
// collection.
- size_t _regionLiveThresholdBytes;
+ size_t _region_live_threshold_bytes;
// The sum of reclaimable bytes over all the regions in the CSet chooser.
- size_t _remainingReclaimableBytes;
+ size_t _remaining_reclaimable_bytes;
public:
@@ -107,9 +72,9 @@
HeapRegion* peek() {
HeapRegion* res = NULL;
if (_curr_index < _length) {
- res = _markedRegions.at(_curr_index);
+ res = regions_at(_curr_index);
assert(res != NULL,
- err_msg("Unexpected NULL hr in _markedRegions at index %d",
+ err_msg("Unexpected NULL hr in _regions at index %u",
_curr_index));
}
return res;
@@ -121,90 +86,71 @@
void remove_and_move_to_next(HeapRegion* hr) {
assert(hr != NULL, "pre-condition");
assert(_curr_index < _length, "pre-condition");
- assert(_markedRegions.at(_curr_index) == hr, "pre-condition");
- hr->set_sort_index(-1);
- _markedRegions.at_put(_curr_index, NULL);
- assert(hr->reclaimable_bytes() <= _remainingReclaimableBytes,
+ assert(regions_at(_curr_index) == hr, "pre-condition");
+ regions_at_put(_curr_index, NULL);
+ assert(hr->reclaimable_bytes() <= _remaining_reclaimable_bytes,
err_msg("remaining reclaimable bytes inconsistent "
"from region: "SIZE_FORMAT" remaining: "SIZE_FORMAT,
- hr->reclaimable_bytes(), _remainingReclaimableBytes));
- _remainingReclaimableBytes -= hr->reclaimable_bytes();
+ hr->reclaimable_bytes(), _remaining_reclaimable_bytes));
+ _remaining_reclaimable_bytes -= hr->reclaimable_bytes();
_curr_index += 1;
}
CollectionSetChooser();
- void sortMarkedHeapRegions();
- void fillCache();
+ void sort_regions();
// Determine whether to add the given region to the CSet chooser or
// not. Currently, we skip humongous regions (we never add them to
// the CSet, we only reclaim them during cleanup) and regions whose
// live bytes are over the threshold.
- bool shouldAdd(HeapRegion* hr) {
+ bool should_add(HeapRegion* hr) {
assert(hr->is_marked(), "pre-condition");
assert(!hr->is_young(), "should never consider young regions");
return !hr->isHumongous() &&
- hr->live_bytes() < _regionLiveThresholdBytes;
+ hr->live_bytes() < _region_live_threshold_bytes;
}
// Calculate the minimum number of old regions we'll add to the CSet
// during a mixed GC.
- uint calcMinOldCSetLength();
+ uint calc_min_old_cset_length();
// Calculate the maximum number of old regions we'll add to the CSet
// during a mixed GC.
- uint calcMaxOldCSetLength();
+ uint calc_max_old_cset_length();
// Serial version.
- void addMarkedHeapRegion(HeapRegion *hr);
+ void add_region(HeapRegion *hr);
- // Must be called before calls to getParMarkedHeapRegionChunk.
- // "n_regions" is the number of regions, "chunkSize" the chunk size.
- void prepareForAddMarkedHeapRegionsPar(uint n_regions, uint chunkSize);
- // Returns the first index in a contiguous chunk of "n_regions" indexes
+ // Must be called before calls to claim_array_chunk().
+ // n_regions is the number of regions, chunk_size the chunk size.
+ void prepare_for_par_region_addition(uint n_regions, uint chunk_size);
+ // Returns the first index in a contiguous chunk of chunk_size indexes
// that the calling thread has reserved. These must be set by the
- // calling thread using "setMarkedHeapRegion" (to NULL if necessary).
- jint getParMarkedHeapRegionChunk(jint n_regions);
+ // calling thread using set_region() (to NULL if necessary).
+ uint claim_array_chunk(uint chunk_size);
// Set the marked array entry at index to hr. Careful to claim the index
// first if in parallel.
- void setMarkedHeapRegion(jint index, HeapRegion* hr);
+ void set_region(uint index, HeapRegion* hr);
// Atomically increment the number of added regions by region_num
// and the amount of reclaimable bytes by reclaimable_bytes.
- void updateTotals(jint region_num, size_t reclaimable_bytes);
+ void update_totals(uint region_num, size_t reclaimable_bytes);
- void clearMarkedHeapRegions();
+ void clear();
// Return the number of candidate regions that remain to be collected.
- uint remainingRegions() { return (uint) (_length - _curr_index); }
+ uint remaining_regions() { return _length - _curr_index; }
// Determine whether the CSet chooser has more candidate regions or not.
- bool isEmpty() { return remainingRegions() == 0; }
+ bool is_empty() { return remaining_regions() == 0; }
// Return the reclaimable bytes that remain to be collected on
// all the candidate regions in the CSet chooser.
- size_t remainingReclaimableBytes () { return _remainingReclaimableBytes; }
+ size_t remaining_reclaimable_bytes() { return _remaining_reclaimable_bytes; }
- // Returns true if the used portion of "_markedRegions" is properly
+ // Returns true if the used portion of "_regions" is properly
// sorted, otherwise asserts false.
-#ifndef PRODUCT
- bool verify(void);
- bool regionProperlyOrdered(HeapRegion* r) {
- int si = r->sort_index();
- if (si > -1) {
- guarantee(_curr_index <= si && si < _length,
- err_msg("curr: %d sort index: %d: length: %d",
- _curr_index, si, _length));
- guarantee(_markedRegions.at(si) == r,
- err_msg("sort index: %d at: "PTR_FORMAT" r: "PTR_FORMAT,
- si, _markedRegions.at(si), r));
- } else {
- guarantee(si == -1, err_msg("sort index: %d", si));
- }
- return true;
- }
-#endif
-
+ void verify() PRODUCT_RETURN;
};
#endif // SHARE_VM_GC_IMPLEMENTATION_G1_COLLECTIONSETCHOOSER_HPP