author | tonyp |
Fri, 10 Jun 2011 13:16:40 -0400 | |
changeset 9989 | 305a76435cf1 |
parent 8680 | f1c414e16a4c |
child 10663 | 3ef855a3329b |
permissions | -rw-r--r-- |
1374 | 1 |
/* |
7920 | 2 |
* Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved. |
1374 | 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 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
3261
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
3261
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
3261
diff
changeset
|
21 |
* questions. |
1374 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#ifndef SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONSEQ_HPP |
26 |
#define SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONSEQ_HPP |
|
27 |
||
1374 | 28 |
class HeapRegion; |
29 |
class HeapRegionClosure; |
|
9989 | 30 |
class FreeRegionList; |
31 |
||
32 |
#define G1_NULL_HRS_INDEX ((size_t) -1) |
|
33 |
||
34 |
// This class keeps track of the region metadata (i.e., HeapRegion |
|
35 |
// instances). They are kept in the _regions array in address |
|
36 |
// order. A region's index in the array corresponds to its index in |
|
37 |
// the heap (i.e., 0 is the region at the bottom of the heap, 1 is |
|
38 |
// the one after it, etc.). Two regions that are consecutive in the |
|
39 |
// array should also be adjacent in the address space (i.e., |
|
40 |
// region(i).end() == region(i+1).bottom(). |
|
41 |
// |
|
42 |
// We create a HeapRegion when we commit the region's address space |
|
43 |
// for the first time. When we uncommit the address space of a |
|
44 |
// region we retain the HeapRegion to be able to re-use it in the |
|
45 |
// future (in case we recommit it). |
|
46 |
// |
|
47 |
// We keep track of three lengths: |
|
48 |
// |
|
49 |
// * _length (returned by length()) is the number of currently |
|
50 |
// committed regions. |
|
51 |
// * _allocated_length (not exposed outside this class) is the |
|
52 |
// number of regions for which we have HeapRegions. |
|
53 |
// * _max_length (returned by max_length()) is the maximum number of |
|
54 |
// regions the heap can have. |
|
55 |
// |
|
56 |
// and maintain that: _length <= _allocated_length <= _max_length |
|
1374 | 57 |
|
58 |
class HeapRegionSeq: public CHeapObj { |
|
59 |
||
9989 | 60 |
// The array that holds the HeapRegions. |
61 |
HeapRegion** _regions; |
|
62 |
||
63 |
// Version of _regions biased to address 0 |
|
64 |
HeapRegion** _regions_biased; |
|
65 |
||
66 |
// The number of regions committed in the heap. |
|
67 |
size_t _length; |
|
1374 | 68 |
|
9989 | 69 |
// The address of the first reserved word in the heap. |
70 |
HeapWord* _heap_bottom; |
|
71 |
||
72 |
// The address of the last reserved word in the heap - 1. |
|
73 |
HeapWord* _heap_end; |
|
74 |
||
75 |
// The log of the region byte size. |
|
76 |
size_t _region_shift; |
|
77 |
||
78 |
// A hint for which index to start searching from for humongous |
|
79 |
// allocations. |
|
80 |
size_t _next_search_index; |
|
1374 | 81 |
|
9989 | 82 |
// The number of regions for which we have allocated HeapRegions for. |
83 |
size_t _allocated_length; |
|
84 |
||
85 |
// The maximum number of regions in the heap. |
|
86 |
size_t _max_length; |
|
87 |
||
88 |
// Find a contiguous set of empty regions of length num, starting |
|
89 |
// from the given index. |
|
90 |
size_t find_contiguous_from(size_t from, size_t num); |
|
1374 | 91 |
|
9989 | 92 |
// Map a heap address to a biased region index. Assume that the |
93 |
// address is valid. |
|
94 |
inline size_t addr_to_index_biased(HeapWord* addr) const; |
|
1374 | 95 |
|
9989 | 96 |
void increment_length(size_t* length) { |
97 |
assert(*length < _max_length, "pre-condition"); |
|
98 |
*length += 1; |
|
99 |
} |
|
100 |
||
101 |
void decrement_length(size_t* length) { |
|
102 |
assert(*length > 0, "pre-condition"); |
|
103 |
*length -= 1; |
|
104 |
} |
|
1374 | 105 |
|
106 |
public: |
|
9989 | 107 |
// Empty contructor, we'll initialize it with the initialize() method. |
108 |
HeapRegionSeq() { } |
|
109 |
||
110 |
void initialize(HeapWord* bottom, HeapWord* end, size_t max_length); |
|
1374 | 111 |
|
9989 | 112 |
// Return the HeapRegion at the given index. Assume that the index |
113 |
// is valid. |
|
114 |
inline HeapRegion* at(size_t index) const; |
|
115 |
||
116 |
// If addr is within the committed space return its corresponding |
|
117 |
// HeapRegion, otherwise return NULL. |
|
118 |
inline HeapRegion* addr_to_region(HeapWord* addr) const; |
|
119 |
||
120 |
// Return the HeapRegion that corresponds to the given |
|
121 |
// address. Assume the address is valid. |
|
122 |
inline HeapRegion* addr_to_region_unsafe(HeapWord* addr) const; |
|
1374 | 123 |
|
9989 | 124 |
// Return the number of regions that have been committed in the heap. |
125 |
size_t length() const { return _length; } |
|
126 |
||
127 |
// Return the maximum number of regions in the heap. |
|
128 |
size_t max_length() const { return _max_length; } |
|
1374 | 129 |
|
9989 | 130 |
// Expand the sequence to reflect that the heap has grown from |
131 |
// old_end to new_end. Either create new HeapRegions, or re-use |
|
132 |
// existing ones, and return them in the given list. Returns the |
|
133 |
// memory region that covers the newly-created regions. If a |
|
134 |
// HeapRegion allocation fails, the result memory region might be |
|
135 |
// smaller than the desired one. |
|
136 |
MemRegion expand_by(HeapWord* old_end, HeapWord* new_end, |
|
137 |
FreeRegionList* list); |
|
1374 | 138 |
|
9989 | 139 |
// Return the number of contiguous regions at the end of the sequence |
1374 | 140 |
// that are available for allocation. |
141 |
size_t free_suffix(); |
|
142 |
||
8680 | 143 |
// Find a contiguous set of empty regions of length num and return |
9989 | 144 |
// the index of the first region or G1_NULL_HRS_INDEX if the |
145 |
// search was unsuccessful. |
|
146 |
size_t find_contiguous(size_t num); |
|
1374 | 147 |
|
9989 | 148 |
// Apply blk->doHeapRegion() on all committed regions in address order, |
149 |
// terminating the iteration early if doHeapRegion() returns true. |
|
150 |
void iterate(HeapRegionClosure* blk) const; |
|
1374 | 151 |
|
9989 | 152 |
// As above, but start the iteration from hr and loop around. If hr |
153 |
// is NULL, we start from the first region in the heap. |
|
154 |
void iterate_from(HeapRegion* hr, HeapRegionClosure* blk) const; |
|
1374 | 155 |
|
9989 | 156 |
// Tag as uncommitted as many regions that are completely free as |
157 |
// possible, up to shrink_bytes, from the suffix of the committed |
|
158 |
// sequence. Return a MemRegion that corresponds to the address |
|
159 |
// range of the uncommitted regions. Assume shrink_bytes is page and |
|
160 |
// heap region aligned. |
|
161 |
MemRegion shrink_by(size_t shrink_bytes, size_t* num_regions_deleted); |
|
1374 | 162 |
|
9989 | 163 |
// Do some sanity checking. |
164 |
void verify_optional() PRODUCT_RETURN; |
|
1374 | 165 |
}; |
7397 | 166 |
|
167 |
#endif // SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONSEQ_HPP |