src/share/vm/gc_implementation/g1/heapRegionSeq.hpp
Print this page
rev 4123 : 7163191: G1: introduce a "heap spanning table" abstraction
Summary: Add a heap spanning table and employ it for the heap region sequence table.
Reviewed-by:
@@ -23,10 +23,12 @@
*/
#ifndef SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONSEQ_HPP
#define SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONSEQ_HPP
+#include "gc_implementation/g1/g1HeapSpanningTable.hpp"
+
class HeapRegion;
class HeapRegionClosure;
class FreeRegionList;
// This class keeps track of the region metadata (i.e., HeapRegion
@@ -40,102 +42,52 @@
// We create a HeapRegion when we commit the region's address space
// for the first time. When we uncommit the address space of a
// region we retain the HeapRegion to be able to re-use it in the
// future (in case we recommit it).
//
-// We keep track of three lengths:
+// We keep track of three lengths (all three are maintained by the
+// G1HeapSpanningTable superclass):
//
// * _length (returned by length()) is the number of currently
// committed regions.
-// * _allocated_length (not exposed outside this class) is the
-// number of regions for which we have HeapRegions.
+// * _length_high_watermark is the number of regions for which we have
+// already allocated HeapRegions.
// * _max_length (returned by max_length()) is the maximum number of
// regions the heap can have.
//
-// and maintain that: _length <= _allocated_length <= _max_length
+// and maintain that: _length <= _length_high_watermark <= _max_length
-class HeapRegionSeq: public CHeapObj<mtGC> {
+class HeapRegionSeq: public G1HeapSpanningTable<HeapRegion*> {
friend class VMStructs;
- // The array that holds the HeapRegions.
+ // The array that holds the HeapRegion instances.
HeapRegion** _regions;
- // Version of _regions biased to address 0
+ // As above, but biased to address 0.
HeapRegion** _regions_biased;
- // The number of regions committed in the heap.
- uint _length;
-
- // The address of the first reserved word in the heap.
- HeapWord* _heap_bottom;
-
- // The address of the last reserved word in the heap - 1.
- HeapWord* _heap_end;
-
- // The log of the region byte size.
- uint _region_shift;
-
// A hint for which index to start searching from for humongous
// allocations.
uint _next_search_index;
- // The number of regions for which we have allocated HeapRegions for.
- uint _allocated_length;
-
- // The maximum number of regions in the heap.
- uint _max_length;
-
// Find a contiguous set of empty regions of length num, starting
// from the given index.
uint find_contiguous_from(uint from, uint num);
- // Map a heap address to a biased region index. Assume that the
- // address is valid.
- inline uintx addr_to_index_biased(HeapWord* addr) const;
-
- void increment_length(uint* length) {
- assert(*length < _max_length, "pre-condition");
- *length += 1;
- }
-
- void decrement_length(uint* length) {
- assert(*length > 0, "pre-condition");
- *length -= 1;
- }
-
public:
- // Empty contructor, we'll initialize it with the initialize() method.
- HeapRegionSeq() { }
-
- void initialize(HeapWord* bottom, HeapWord* end, uint max_length);
// Return the HeapRegion at the given index. Assume that the index
// is valid.
inline HeapRegion* at(uint index) const;
// If addr is within the committed space return its corresponding
// HeapRegion, otherwise return NULL.
- inline HeapRegion* addr_to_region(HeapWord* addr) const;
-
- // Return the HeapRegion that corresponds to the given
- // address. Assume the address is valid.
- inline HeapRegion* addr_to_region_unsafe(HeapWord* addr) const;
+ inline HeapRegion* at(HeapWord* addr) const;
- // Return the number of regions that have been committed in the heap.
- uint length() const { return _length; }
-
- // Return the maximum number of regions in the heap.
- uint max_length() const { return _max_length; }
-
- // Expand the sequence to reflect that the heap has grown from
- // old_end to new_end. Either create new HeapRegions, or re-use
- // existing ones, and return them in the given list. Returns the
- // memory region that covers the newly-created regions. If a
- // HeapRegion allocation fails, the result memory region might be
- // smaller than the desired one.
- MemRegion expand_by(HeapWord* old_end, HeapWord* new_end,
- FreeRegionList* list);
+ // Return the HeapRegion that corresponds to the given address.
+ // Assume the address is valid.
+ inline HeapRegion* at_unsafe(HeapWord* addr) const;
// Return the number of contiguous regions at the end of the sequence
// that are available for allocation.
uint free_suffix();
@@ -150,17 +102,29 @@
// As above, but start the iteration from hr and loop around. If hr
// is NULL, we start from the first region in the heap.
void iterate_from(HeapRegion* hr, HeapRegionClosure* blk) const;
+ // Expand the sequence to reflect that the heap has grown from
+ // old_end to new_end. Either create new HeapRegions, or re-use
+ // existing ones, and return them in the given list. Returns the
+ // memory region that covers the newly-created regions. If a
+ // HeapRegion allocation fails, the returned memory region might be
+ // smaller than the desired one.
+ MemRegion expand_to(HeapWord* new_end, FreeRegionList* list);
+
// Tag as uncommitted as many regions that are completely free as
- // possible, up to shrink_bytes, from the suffix of the committed
+ // possible, up to new_end, from the suffix of the committed
// sequence. Return a MemRegion that corresponds to the address
- // range of the uncommitted regions. Assume shrink_bytes is page and
- // heap region aligned.
- MemRegion shrink_by(size_t shrink_bytes, uint* num_regions_deleted);
+ // range of the uncommitted regions.
+ MemRegion shrink_to(HeapWord* new_end, uint* num_regions_deleted);
- // Do some sanity checking.
+ // Do sanity checking.
void verify_optional() PRODUCT_RETURN;
+
+ // Empty constructor, we'll do all initialization in the initialize() method.
+ HeapRegionSeq() { }
+
+ void initialize(HeapWord* bottom, HeapWord* max_end);
};
#endif // SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONSEQ_HPP