1 /*
2 * Copyright (c) 2001, 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #ifndef SHARE_VM_GC_G1_HEAPREGIONMANAGER_HPP
26 #define SHARE_VM_GC_G1_HEAPREGIONMANAGER_HPP
27
28 #include "gc/g1/g1BiasedArray.hpp"
29 #include "gc/g1/g1RegionToSpaceMapper.hpp"
30 #include "gc/g1/heapRegionSet.hpp"
31 #include "services/memoryUsage.hpp"
32
33 class HeapRegion;
34 class HeapRegionClosure;
35 class HeapRegionClaimer;
36 class FreeRegionList;
37
38 class G1HeapRegionTable : public G1BiasedMappedArray<HeapRegion*> {
39 protected:
40 virtual HeapRegion* default_value() const { return NULL; }
41 };
42
43 // This class keeps track of the actual heap memory, auxiliary data
44 // and its metadata (i.e., HeapRegion instances) and the list of free regions.
45 //
46 // This allows maximum flexibility for deciding what to commit or uncommit given
47 // a request from outside.
48 //
49 // HeapRegions are kept in the _regions array in address order. A region's
50 // index in the array corresponds to its index in the heap (i.e., 0 is the
51 // region at the bottom of the heap, 1 is the one after it, etc.). Two
52 // regions that are consecutive in the array should also be adjacent in the
53 // address space (i.e., region(i).end() == region(i+1).bottom().
54 //
55 // We create a HeapRegion when we commit the region's address space
56 // for the first time. When we uncommit the address space of a
77 G1RegionToSpaceMapper* _next_bitmap_mapper;
78 G1RegionToSpaceMapper* _bot_mapper;
79 G1RegionToSpaceMapper* _cardtable_mapper;
80 G1RegionToSpaceMapper* _card_counts_mapper;
81
82 FreeRegionList _free_list;
83
84 // Each bit in this bitmap indicates that the corresponding region is available
85 // for allocation.
86 CHeapBitMap _available_map;
87
88 // The number of regions committed in the heap.
89 uint _num_committed;
90
91 // Internal only. The highest heap region +1 we allocated a HeapRegion instance for.
92 uint _allocated_heapregions_length;
93
94 HeapWord* heap_bottom() const { return _regions.bottom_address_mapped(); }
95 HeapWord* heap_end() const {return _regions.end_address_mapped(); }
96
97 void make_regions_available(uint index, uint num_regions = 1);
98
99 // Pass down commit calls to the VirtualSpace.
100 void commit_regions(uint index, size_t num_regions = 1);
101 void uncommit_regions(uint index, size_t num_regions = 1);
102
103 // Notify other data structures about change in the heap layout.
104 void update_committed_space(HeapWord* old_end, HeapWord* new_end);
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_HRM_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);
111 // Finds the next sequence of unavailable regions starting from start_idx. Returns the
112 // length of the sequence found. If this result is zero, no such sequence could be found,
113 // otherwise res_idx indicates the start index of these regions.
114 uint find_unavailable_from_idx(uint start_idx, uint* res_idx) const;
115 // Finds the next sequence of empty regions starting from start_idx, going backwards in
116 // the heap. Returns the length of the sequence found. If this value is zero, no
117 // sequence could be found, otherwise res_idx contains the start index of this range.
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 hrm_index);
192 return num_free_regions() * HeapRegion::GrainBytes;
193 }
194
195 // Return the number of available (uncommitted) regions.
196 uint available() const { return max_length() - length(); }
197
198 // Return the number of regions that have been committed in the heap.
199 uint length() const { return _num_committed; }
200
201 // Return the maximum number of regions in the heap.
202 uint max_length() const { return (uint)_regions.length(); }
203
204 MemoryUsage get_auxiliary_data_memory_usage() const;
205
206 MemRegion reserved() const { return MemRegion(heap_bottom(), heap_end()); }
207
208 // Expand the sequence to reflect that the heap has grown. Either create new
209 // HeapRegions, or re-use existing ones. Returns the number of regions the
210 // sequence was expanded by. If a HeapRegion allocation fails, the resulting
211 // number of regions might be smaller than what's desired.
212 uint expand_by(uint num_regions);
213
214 // Makes sure that the regions from start to start+num_regions-1 are available
215 // for allocation. Returns the number of regions that were committed to achieve
216 // this.
217 uint expand_at(uint start, uint num_regions);
218
219 // Find a contiguous set of empty regions of length num. Returns the start index of
220 // that set, or G1_NO_HRM_INDEX.
221 uint find_contiguous_only_empty(size_t num) { return find_contiguous(num, true); }
222 // Find a contiguous set of empty or unavailable regions of length num. Returns the
223 // start index of that set, or G1_NO_HRM_INDEX.
224 uint find_contiguous_empty_or_unavailable(size_t num) { return find_contiguous(num, false); }
225
226 HeapRegion* next_region_in_heap(const HeapRegion* r) const;
227
228 // Find the highest free or uncommitted region in the reserved heap,
229 // and if uncommitted, commit it. If none are available, return G1_NO_HRM_INDEX.
230 // Set the 'expanded' boolean true if a new region was committed.
231 uint find_highest_free(bool* expanded);
232
233 // Allocate the regions that contain the address range specified, committing the
234 // regions if necessary. Return false if any of the regions is already committed
235 // and not free, and return the number of regions newly committed in commit_count.
236 bool allocate_containing_regions(MemRegion range, size_t* commit_count);
237
|
1 /*
2 * Copyright (c) 2001, 2016, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #ifndef SHARE_VM_GC_G1_HEAPREGIONMANAGER_HPP
26 #define SHARE_VM_GC_G1_HEAPREGIONMANAGER_HPP
27
28 #include "gc/g1/g1BiasedArray.hpp"
29 #include "gc/g1/g1RegionToSpaceMapper.hpp"
30 #include "gc/g1/heapRegionSet.hpp"
31 #include "services/memoryUsage.hpp"
32
33 class HeapRegion;
34 class HeapRegionClosure;
35 class HeapRegionClaimer;
36 class FreeRegionList;
37 class WorkGang;
38
39 class G1HeapRegionTable : public G1BiasedMappedArray<HeapRegion*> {
40 protected:
41 virtual HeapRegion* default_value() const { return NULL; }
42 };
43
44 // This class keeps track of the actual heap memory, auxiliary data
45 // and its metadata (i.e., HeapRegion instances) and the list of free regions.
46 //
47 // This allows maximum flexibility for deciding what to commit or uncommit given
48 // a request from outside.
49 //
50 // HeapRegions are kept in the _regions array in address order. A region's
51 // index in the array corresponds to its index in the heap (i.e., 0 is the
52 // region at the bottom of the heap, 1 is the one after it, etc.). Two
53 // regions that are consecutive in the array should also be adjacent in the
54 // address space (i.e., region(i).end() == region(i+1).bottom().
55 //
56 // We create a HeapRegion when we commit the region's address space
57 // for the first time. When we uncommit the address space of a
78 G1RegionToSpaceMapper* _next_bitmap_mapper;
79 G1RegionToSpaceMapper* _bot_mapper;
80 G1RegionToSpaceMapper* _cardtable_mapper;
81 G1RegionToSpaceMapper* _card_counts_mapper;
82
83 FreeRegionList _free_list;
84
85 // Each bit in this bitmap indicates that the corresponding region is available
86 // for allocation.
87 CHeapBitMap _available_map;
88
89 // The number of regions committed in the heap.
90 uint _num_committed;
91
92 // Internal only. The highest heap region +1 we allocated a HeapRegion instance for.
93 uint _allocated_heapregions_length;
94
95 HeapWord* heap_bottom() const { return _regions.bottom_address_mapped(); }
96 HeapWord* heap_end() const {return _regions.end_address_mapped(); }
97
98 void make_regions_available(uint index, uint num_regions = 1, WorkGang* pretouch_gang = NULL);
99
100 // Pass down commit calls to the VirtualSpace.
101 void commit_regions(uint index, size_t num_regions = 1, WorkGang* pretouch_gang = NULL);
102 void uncommit_regions(uint index, size_t num_regions = 1);
103
104 // Notify other data structures about change in the heap layout.
105 void update_committed_space(HeapWord* old_end, HeapWord* new_end);
106
107 // Find a contiguous set of empty or uncommitted regions of length num and return
108 // the index of the first region or G1_NO_HRM_INDEX if the search was unsuccessful.
109 // If only_empty is true, only empty regions are considered.
110 // Searches from bottom to top of the heap, doing a first-fit.
111 uint find_contiguous(size_t num, bool only_empty);
112 // Finds the next sequence of unavailable regions starting from start_idx. Returns the
113 // length of the sequence found. If this result is zero, no such sequence could be found,
114 // otherwise res_idx indicates the start index of these regions.
115 uint find_unavailable_from_idx(uint start_idx, uint* res_idx) const;
116 // Finds the next sequence of empty regions starting from start_idx, going backwards in
117 // the heap. Returns the length of the sequence found. If this value is zero, no
118 // sequence could be found, otherwise res_idx contains the start index of this range.
119 uint find_empty_from_idx_reverse(uint start_idx, uint* res_idx) const;
120 // Allocate a new HeapRegion for the given index.
121 HeapRegion* new_heap_region(uint hrm_index);
193 return num_free_regions() * HeapRegion::GrainBytes;
194 }
195
196 // Return the number of available (uncommitted) regions.
197 uint available() const { return max_length() - length(); }
198
199 // Return the number of regions that have been committed in the heap.
200 uint length() const { return _num_committed; }
201
202 // Return the maximum number of regions in the heap.
203 uint max_length() const { return (uint)_regions.length(); }
204
205 MemoryUsage get_auxiliary_data_memory_usage() const;
206
207 MemRegion reserved() const { return MemRegion(heap_bottom(), heap_end()); }
208
209 // Expand the sequence to reflect that the heap has grown. Either create new
210 // HeapRegions, or re-use existing ones. Returns the number of regions the
211 // sequence was expanded by. If a HeapRegion allocation fails, the resulting
212 // number of regions might be smaller than what's desired.
213 uint expand_by(uint num_regions, WorkGang* pretouch_workers = NULL);
214
215 // Makes sure that the regions from start to start+num_regions-1 are available
216 // for allocation. Returns the number of regions that were committed to achieve
217 // this.
218 uint expand_at(uint start, uint num_regions, WorkGang* pretouch_workers = NULL);
219
220 // Find a contiguous set of empty regions of length num. Returns the start index of
221 // that set, or G1_NO_HRM_INDEX.
222 uint find_contiguous_only_empty(size_t num) { return find_contiguous(num, true); }
223 // Find a contiguous set of empty or unavailable regions of length num. Returns the
224 // start index of that set, or G1_NO_HRM_INDEX.
225 uint find_contiguous_empty_or_unavailable(size_t num) { return find_contiguous(num, false); }
226
227 HeapRegion* next_region_in_heap(const HeapRegion* r) const;
228
229 // Find the highest free or uncommitted region in the reserved heap,
230 // and if uncommitted, commit it. If none are available, return G1_NO_HRM_INDEX.
231 // Set the 'expanded' boolean true if a new region was committed.
232 uint find_highest_free(bool* expanded);
233
234 // Allocate the regions that contain the address range specified, committing the
235 // regions if necessary. Return false if any of the regions is already committed
236 // and not free, and return the number of regions newly committed in commit_count.
237 bool allocate_containing_regions(MemRegion range, size_t* commit_count);
238
|