Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/heapRegionSeq.hpp @ 20337:1f1d373cd044

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
8038423: G1: Decommit memory within heap Summary: Allow G1 to decommit memory of arbitrary regions within the heap and their associated auxiliary data structures card table, BOT, hot card cache, and mark bitmaps. Reviewed-by: mgerdin, brutisso, jwilhelm
author tschatzl
date Thu, 21 Aug 2014 11:47:10 +0200
parents 6701abbc4441
children
comparison
equal deleted inserted replaced
20336:6701abbc4441 20337:1f1d373cd044
24 24
25 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONSEQ_HPP 25 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONSEQ_HPP
26 #define SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONSEQ_HPP 26 #define SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONSEQ_HPP
27 27
28 #include "gc_implementation/g1/g1BiasedArray.hpp" 28 #include "gc_implementation/g1/g1BiasedArray.hpp"
29 #include "gc_implementation/g1/g1RegionToSpaceMapper.hpp"
29 #include "gc_implementation/g1/heapRegionSet.hpp" 30 #include "gc_implementation/g1/heapRegionSet.hpp"
30 31
31 class HeapRegion; 32 class HeapRegion;
32 class HeapRegionClosure; 33 class HeapRegionClosure;
33 class FreeRegionList; 34 class FreeRegionList;
35 class G1HeapRegionTable : public G1BiasedMappedArray<HeapRegion*> { 36 class G1HeapRegionTable : public G1BiasedMappedArray<HeapRegion*> {
36 protected: 37 protected:
37 virtual HeapRegion* default_value() const { return NULL; } 38 virtual HeapRegion* default_value() const { return NULL; }
38 }; 39 };
39 40
40 // This class keeps track of the region metadata (i.e., HeapRegion 41 // This class keeps track of the actual heap memory, auxiliary data
41 // instances). They are kept in the _regions array in address 42 // and its metadata (i.e., HeapRegion instances) and the list of free regions.
42 // order. A region's index in the array corresponds to its index in 43 //
43 // the heap (i.e., 0 is the region at the bottom of the heap, 1 is 44 // This allows maximum flexibility for deciding what to commit or uncommit given
44 // the one after it, etc.). Two regions that are consecutive in the 45 // a request from outside.
45 // array should also be adjacent in the address space (i.e., 46 //
46 // region(i).end() == region(i+1).bottom(). 47 // HeapRegions are kept in the _regions array in address order. A region's
48 // index in the array corresponds to its index in the heap (i.e., 0 is the
49 // region at the bottom of the heap, 1 is the one after it, etc.). Two
50 // regions that are consecutive in the array should also be adjacent in the
51 // address space (i.e., region(i).end() == region(i+1).bottom().
47 // 52 //
48 // We create a HeapRegion when we commit the region's address space 53 // We create a HeapRegion when we commit the region's address space
49 // for the first time. When we uncommit the address space of a 54 // for the first time. When we uncommit the address space of a
50 // region we retain the HeapRegion to be able to re-use it in the 55 // region we retain the HeapRegion to be able to re-use it in the
51 // future (in case we recommit it). 56 // future (in case we recommit it).
52 // 57 //
53 // We keep track of three lengths: 58 // We keep track of three lengths:
54 // 59 //
55 // * _committed_length (returned by length()) is the number of currently 60 // * _num_committed (returned by length()) is the number of currently
56 // committed regions. 61 // committed regions. These may not be contiguous.
57 // * _allocated_length (not exposed outside this class) is the 62 // * _allocated_heapregions_length (not exposed outside this class) is the
58 // number of regions for which we have HeapRegions. 63 // number of regions+1 for which we have HeapRegions.
59 // * max_length() returns the maximum number of regions the heap can have. 64 // * max_length() returns the maximum number of regions the heap can have.
60 // 65 //
61 // and maintain that: _committed_length <= _allocated_length <= max_length()
62 66
63 class HeapRegionSeq: public CHeapObj<mtGC> { 67 class HeapRegionSeq: public CHeapObj<mtGC> {
64 friend class VMStructs; 68 friend class VMStructs;
65 69
66 G1HeapRegionTable _regions; 70 G1HeapRegionTable _regions;
67 71
68 ReservedSpace _reserved; 72 G1RegionToSpaceMapper* _heap_mapper;
69 VirtualSpace _storage; 73 G1RegionToSpaceMapper* _prev_bitmap_mapper;
74 G1RegionToSpaceMapper* _next_bitmap_mapper;
75 G1RegionToSpaceMapper* _bot_mapper;
76 G1RegionToSpaceMapper* _cardtable_mapper;
77 G1RegionToSpaceMapper* _card_counts_mapper;
70 78
71 FreeRegionList _free_list; 79 FreeRegionList _free_list;
80
81 // Each bit in this bitmap indicates that the corresponding region is available
82 // for allocation.
83 BitMap _available_map;
72 84
73 // The number of regions committed in the heap. 85 // The number of regions committed in the heap.
74 uint _num_committed; 86 uint _num_committed;
75 87
76 // Internal only. The highest heap region +1 we allocated a HeapRegion instance for. 88 // Internal only. The highest heap region +1 we allocated a HeapRegion instance for.
77 uint _allocated_heapregions_length; 89 uint _allocated_heapregions_length;
78 90
79 HeapWord* heap_bottom() const { return _regions.bottom_address_mapped(); } 91 HeapWord* heap_bottom() const { return _regions.bottom_address_mapped(); }
80 HeapWord* heap_top() const { return heap_bottom() + _num_committed * HeapRegion::GrainWords; }
81 HeapWord* heap_end() const {return _regions.end_address_mapped(); } 92 HeapWord* heap_end() const {return _regions.end_address_mapped(); }
82 93
83 void make_regions_available(uint index, uint num_regions = 1); 94 void make_regions_available(uint index, uint num_regions = 1);
84 95
85 // Pass down commit calls to the VirtualSpace. 96 // Pass down commit calls to the VirtualSpace.
90 void update_committed_space(HeapWord* old_end, HeapWord* new_end); 101 void update_committed_space(HeapWord* old_end, HeapWord* new_end);
91 // Calculate the starting region for each worker during parallel iteration so 102 // Calculate the starting region for each worker during parallel iteration so
92 // that they do not all start from the same region. 103 // that they do not all start from the same region.
93 uint start_region_for_worker(uint worker_i, uint num_workers, uint num_regions) const; 104 uint start_region_for_worker(uint worker_i, uint num_workers, uint num_regions) const;
94 105
106 // Find a contiguous set of empty or uncommitted regions of length num and return
107 // the index of the first region or G1_NO_HRS_INDEX if the search was unsuccessful.
108 // If only_empty is true, only empty regions are considered.
109 // Searches from bottom to top of the heap, doing a first-fit.
110 uint find_contiguous(size_t num, bool only_empty);
95 // Finds the next sequence of unavailable regions starting from start_idx. Returns the 111 // Finds the next sequence of unavailable regions starting from start_idx. Returns the
96 // length of the sequence found. If this result is zero, no such sequence could be found, 112 // length of the sequence found. If this result is zero, no such sequence could be found,
97 // otherwise res_idx indicates the start index of these regions. 113 // otherwise res_idx indicates the start index of these regions.
98 uint find_unavailable_from_idx(uint start_idx, uint* res_idx) const; 114 uint find_unavailable_from_idx(uint start_idx, uint* res_idx) const;
99 // Finds the next sequence of empty regions starting from start_idx, going backwards in 115 // Finds the next sequence of empty regions starting from start_idx, going backwards in
100 // the heap. Returns the length of the sequence found. If this value is zero, no 116 // the heap. Returns the length of the sequence found. If this value is zero, no
101 // sequence could be found, otherwise res_idx contains the start index of this range. 117 // sequence could be found, otherwise res_idx contains the start index of this range.
102 uint find_empty_from_idx_reverse(uint start_idx, uint* res_idx) const; 118 uint find_empty_from_idx_reverse(uint start_idx, uint* res_idx) const;
119 // Allocate a new HeapRegion for the given index.
120 HeapRegion* new_heap_region(uint hrs_index);
103 #ifdef ASSERT 121 #ifdef ASSERT
104 public: 122 public:
105 bool is_free(HeapRegion* hr) const; 123 bool is_free(HeapRegion* hr) const;
106 #endif 124 #endif
107 // Returns whether the given region is available for allocation. 125 // Returns whether the given region is available for allocation.
108 bool is_available(uint region) const; 126 bool is_available(uint region) const;
109 127
110 // Allocate a new HeapRegion for the given index.
111 HeapRegion* new_heap_region(uint hrs_index);
112 public: 128 public:
113 // Empty constructor, we'll initialize it with the initialize() method. 129 // Empty constructor, we'll initialize it with the initialize() method.
114 HeapRegionSeq() : _regions(), _reserved(), _storage(), _num_committed(0), 130 HeapRegionSeq() : _regions(), _heap_mapper(NULL), _num_committed(0),
115 _free_list("Master Free List", new MasterFreeRegionListMtSafeChecker()), 131 _next_bitmap_mapper(NULL), _prev_bitmap_mapper(NULL), _bot_mapper(NULL),
116 _allocated_heapregions_length(0) 132 _allocated_heapregions_length(0), _available_map(),
133 _free_list("Free list", new MasterFreeRegionListMtSafeChecker())
117 { } 134 { }
118 135
119 void initialize(ReservedSpace reserved); 136 void initialize(G1RegionToSpaceMapper* heap_storage,
137 G1RegionToSpaceMapper* prev_bitmap,
138 G1RegionToSpaceMapper* next_bitmap,
139 G1RegionToSpaceMapper* bot,
140 G1RegionToSpaceMapper* cardtable,
141 G1RegionToSpaceMapper* card_counts);
120 142
121 // Return the "dummy" region used for G1AllocRegion. This is currently a hardwired 143 // Return the "dummy" region used for G1AllocRegion. This is currently a hardwired
122 // new HeapRegion that owns HeapRegion at index 0. Since at the moment we commit 144 // new HeapRegion that owns HeapRegion at index 0. Since at the moment we commit
123 // the heap from the lowest address, this region (and its associated data 145 // the heap from the lowest address, this region (and its associated data
124 // structures) are available and we do not need to check further. 146 // structures) are available and we do not need to check further.
173 uint length() const { return _num_committed; } 195 uint length() const { return _num_committed; }
174 196
175 // Return the maximum number of regions in the heap. 197 // Return the maximum number of regions in the heap.
176 uint max_length() const { return (uint)_regions.length(); } 198 uint max_length() const { return (uint)_regions.length(); }
177 199
178 MemRegion committed() const { return MemRegion(heap_bottom(), heap_top()); }
179
180 MemRegion reserved() const { return MemRegion(heap_bottom(), heap_end()); } 200 MemRegion reserved() const { return MemRegion(heap_bottom(), heap_end()); }
181 201
182 // Expand the sequence to reflect that the heap has grown. Either create new 202 // Expand the sequence to reflect that the heap has grown. Either create new
183 // HeapRegions, or re-use existing ones. Returns the number of regions the 203 // HeapRegions, or re-use existing ones. Returns the number of regions the
184 // sequence was expanded by. If a HeapRegion allocation fails, the resulting 204 // sequence was expanded by. If a HeapRegion allocation fails, the resulting
188 // Makes sure that the regions from start to start+num_regions-1 are available 208 // Makes sure that the regions from start to start+num_regions-1 are available
189 // for allocation. Returns the number of regions that were committed to achieve 209 // for allocation. Returns the number of regions that were committed to achieve
190 // this. 210 // this.
191 uint expand_at(uint start, uint num_regions); 211 uint expand_at(uint start, uint num_regions);
192 212
193 // Find a contiguous set of empty or uncommitted regions of length num and return 213 // Find a contiguous set of empty regions of length num. Returns the start index of
194 // the index of the first region or G1_NO_HRS_INDEX if the search was unsuccessful. 214 // that set, or G1_NO_HRS_INDEX.
195 // If only_empty is true, only empty regions are considered. 215 uint find_contiguous_only_empty(size_t num) { return find_contiguous(num, true); }
196 // Searches from bottom to top of the heap, doing a first-fit. 216 // Find a contiguous set of empty or unavailable regions of length num. Returns the
197 uint find_contiguous(size_t num, bool only_empty); 217 // start index of that set, or G1_NO_HRS_INDEX.
218 uint find_contiguous_empty_or_unavailable(size_t num) { return find_contiguous(num, false); }
198 219
199 HeapRegion* next_region_in_heap(const HeapRegion* r) const; 220 HeapRegion* next_region_in_heap(const HeapRegion* r) const;
200 221
201 // Apply blk->doHeapRegion() on all committed regions in address order, 222 // Apply blk->doHeapRegion() on all committed regions in address order,
202 // terminating the iteration early if doHeapRegion() returns true. 223 // terminating the iteration early if doHeapRegion() returns true.