src/share/vm/gc_implementation/g1/heapRegionSeq.hpp
Print this page
rev 4204 : 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:
rev 4205 : imported patch bengt-and-thomas-comments
*** 23,32 ****
--- 23,34 ----
*/
#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,141 ****
// 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:
//
// * _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.
// * _max_length (returned by max_length()) is the maximum number of
// regions the heap can have.
//
! // and maintain that: _length <= _allocated_length <= _max_length
! class HeapRegionSeq: public CHeapObj<mtGC> {
friend class VMStructs;
! // The array that holds the HeapRegions.
HeapRegion** _regions;
! // Version of _regions 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;
!
! // 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 number of contiguous regions at the end of the sequence
// that are available for allocation.
uint free_suffix();
--- 42,98 ----
// 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 (all three are maintained by the
! // G1HeapSpanningTable superclass):
//
// * _length (returned by length()) is the number of currently
// committed regions.
! // * _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 <= _length_high_watermark <= _max_length
! class HeapRegionSeq: public G1HeapSpanningTable<HeapRegion*> {
friend class VMStructs;
! // The array that holds the HeapRegion instances.
HeapRegion** _regions;
! // As above, but biased to address 0.
HeapRegion** _regions_biased;
// A hint for which index to start searching from for humongous
// allocations.
uint _next_search_index;
// Find a contiguous set of empty regions of length num, starting
// from the given index.
uint find_contiguous_from(uint from, uint num);
! // Override
! virtual HeapRegion* default_value() const {
! return (HeapRegion*) NULL;
}
public:
// 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* at(HeapWord* addr) const;
! // 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,166 ****
// 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;
// Tag as uncommitted as many regions that are completely free as
! // possible, up to shrink_bytes, 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);
! // Do some sanity checking.
void verify_optional() PRODUCT_RETURN;
};
#endif // SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONSEQ_HPP
--- 107,135 ----
// 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 new_end, from the suffix of the committed
// sequence. Return a MemRegion that corresponds to the address
! // range of the uncommitted regions.
! MemRegion shrink_to(HeapWord* new_end, uint* num_regions_deleted);
! // 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