Mercurial > hg > graal-compiler
annotate src/share/vm/gc_implementation/g1/heapRegionSet.cpp @ 17833:bfdf528be8e8
8038498: Fix includes and C inlining after 8035330
Summary: Change 8035330: Remove G1ParScanPartialArrayClosure and G1ParScanHeapEvacClosure broke the debug build on AIX. The method do_oop_partial_array() is added in a header, but requires the inline function par_write_ref() through several inlined calls. In some cpp files, like arguments.cpp, par_write_ref() is not defined as the corresponding inline header and is not included. The AIX debug VM does not start because of the missing symbol. This change solves this by cleaning up include dependencies.
Reviewed-by: tschatzl, stefank
author | tschatzl |
---|---|
date | Fri, 04 Apr 2014 10:43:56 +0200 |
parents | 8ee855b4e667 |
children | 78bbf4d43a14 |
rev | line source |
---|---|
2152 | 1 /* |
17773
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
2 * Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved. |
2152 | 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 #include "precompiled.hpp" | |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
26 #include "gc_implementation/g1/heapRegionRemSet.hpp" |
2152 | 27 #include "gc_implementation/g1/heapRegionSet.inline.hpp" |
28 | |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
29 uint FreeRegionList::_unrealistically_long_length = 0; |
2152 | 30 |
2361 | 31 void HeapRegionSetBase::fill_in_ext_msg(hrs_ext_msg* msg, const char* message) { |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
32 msg->append("[%s] %s ln: %u cy: "SIZE_FORMAT, |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
33 name(), message, length(), total_capacity_bytes()); |
2152 | 34 fill_in_ext_msg_extra(msg); |
35 } | |
36 | |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
37 #ifndef PRODUCT |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
38 void HeapRegionSetBase::verify_region(HeapRegion* hr) { |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
39 assert(hr->containing_set() == this, err_msg("Inconsistent containing set for %u", hr->hrs_index())); |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
40 assert(!hr->is_young(), err_msg("Adding young region %u", hr->hrs_index())); // currently we don't use these sets for young regions |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
41 assert(hr->isHumongous() == regions_humongous(), err_msg("Wrong humongous state for region %u and set %s", hr->hrs_index(), name())); |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
42 assert(hr->is_empty() == regions_empty(), err_msg("Wrong empty state for region %u and set %s", hr->hrs_index(), name())); |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
43 assert(hr->rem_set()->verify_ready_for_par_iteration(), err_msg("Wrong iteration state %u", hr->hrs_index())); |
2152 | 44 } |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
45 #endif |
2152 | 46 |
47 void HeapRegionSetBase::verify() { | |
48 // It's important that we also observe the MT safety protocol even | |
49 // for the verification calls. If we do verification without the | |
50 // appropriate locks and the set changes underneath our feet | |
51 // verification might fail and send us on a wild goose chase. | |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
52 check_mt_safety(); |
2152 | 53 |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
54 guarantee(( is_empty() && length() == 0 && total_capacity_bytes() == 0) || |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
55 (!is_empty() && length() >= 0 && total_capacity_bytes() >= 0), |
2361 | 56 hrs_ext_msg(this, "invariant")); |
2152 | 57 } |
58 | |
59 void HeapRegionSetBase::verify_start() { | |
60 // See comment in verify() about MT safety and verification. | |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
61 check_mt_safety(); |
2152 | 62 assert(!_verify_in_progress, |
2361 | 63 hrs_ext_msg(this, "verification should not be in progress")); |
2152 | 64 |
65 // Do the basic verification first before we do the checks over the regions. | |
66 HeapRegionSetBase::verify(); | |
67 | |
68 _verify_in_progress = true; | |
69 } | |
70 | |
71 void HeapRegionSetBase::verify_end() { | |
72 // See comment in verify() about MT safety and verification. | |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
73 check_mt_safety(); |
2152 | 74 assert(_verify_in_progress, |
2361 | 75 hrs_ext_msg(this, "verification should be in progress")); |
2152 | 76 |
77 _verify_in_progress = false; | |
78 } | |
79 | |
80 void HeapRegionSetBase::print_on(outputStream* out, bool print_contents) { | |
81 out->cr(); | |
82 out->print_cr("Set: %s ("PTR_FORMAT")", name(), this); | |
83 out->print_cr(" Region Assumptions"); | |
84 out->print_cr(" humongous : %s", BOOL_TO_STR(regions_humongous())); | |
85 out->print_cr(" empty : %s", BOOL_TO_STR(regions_empty())); | |
86 out->print_cr(" Attributes"); | |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
4072
diff
changeset
|
87 out->print_cr(" length : %14u", length()); |
2152 | 88 out->print_cr(" total capacity : "SIZE_FORMAT_W(14)" bytes", |
89 total_capacity_bytes()); | |
90 } | |
91 | |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
92 HeapRegionSetBase::HeapRegionSetBase(const char* name, bool humongous, bool empty, HRSMtSafeChecker* mt_safety_checker) |
2152 | 93 : _name(name), _verify_in_progress(false), |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
94 _is_humongous(humongous), _is_empty(empty), _mt_safety_checker(mt_safety_checker), |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
95 _count() |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
96 { } |
2152 | 97 |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
98 void FreeRegionList::set_unrealistically_long_length(uint len) { |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
99 guarantee(_unrealistically_long_length == 0, "should only be set once"); |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
100 _unrealistically_long_length = len; |
2152 | 101 } |
102 | |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
103 void FreeRegionList::fill_in_ext_msg_extra(hrs_ext_msg* msg) { |
2152 | 104 msg->append(" hd: "PTR_FORMAT" tl: "PTR_FORMAT, head(), tail()); |
105 } | |
106 | |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
107 void FreeRegionList::add_as_head_or_tail(FreeRegionList* from_list, bool as_head) { |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
108 check_mt_safety(); |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
109 from_list->check_mt_safety(); |
2432
455328d90876
7029458: G1: Add newly-reclaimed regions to the beginning of the region free list, not the end
tonyp
parents:
2361
diff
changeset
|
110 |
455328d90876
7029458: G1: Add newly-reclaimed regions to the beginning of the region free list, not the end
tonyp
parents:
2361
diff
changeset
|
111 verify_optional(); |
455328d90876
7029458: G1: Add newly-reclaimed regions to the beginning of the region free list, not the end
tonyp
parents:
2361
diff
changeset
|
112 from_list->verify_optional(); |
455328d90876
7029458: G1: Add newly-reclaimed regions to the beginning of the region free list, not the end
tonyp
parents:
2361
diff
changeset
|
113 |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
114 if (from_list->is_empty()) { |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
115 return; |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
116 } |
2432
455328d90876
7029458: G1: Add newly-reclaimed regions to the beginning of the region free list, not the end
tonyp
parents:
2361
diff
changeset
|
117 |
455328d90876
7029458: G1: Add newly-reclaimed regions to the beginning of the region free list, not the end
tonyp
parents:
2361
diff
changeset
|
118 #ifdef ASSERT |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
119 FreeRegionListIterator iter(from_list); |
2432
455328d90876
7029458: G1: Add newly-reclaimed regions to the beginning of the region free list, not the end
tonyp
parents:
2361
diff
changeset
|
120 while (iter.more_available()) { |
455328d90876
7029458: G1: Add newly-reclaimed regions to the beginning of the region free list, not the end
tonyp
parents:
2361
diff
changeset
|
121 HeapRegion* hr = iter.get_next(); |
455328d90876
7029458: G1: Add newly-reclaimed regions to the beginning of the region free list, not the end
tonyp
parents:
2361
diff
changeset
|
122 // In set_containing_set() we check that we either set the value |
455328d90876
7029458: G1: Add newly-reclaimed regions to the beginning of the region free list, not the end
tonyp
parents:
2361
diff
changeset
|
123 // from NULL to non-NULL or vice versa to catch bugs. So, we have |
455328d90876
7029458: G1: Add newly-reclaimed regions to the beginning of the region free list, not the end
tonyp
parents:
2361
diff
changeset
|
124 // to NULL it first before setting it to the value. |
455328d90876
7029458: G1: Add newly-reclaimed regions to the beginning of the region free list, not the end
tonyp
parents:
2361
diff
changeset
|
125 hr->set_containing_set(NULL); |
455328d90876
7029458: G1: Add newly-reclaimed regions to the beginning of the region free list, not the end
tonyp
parents:
2361
diff
changeset
|
126 hr->set_containing_set(this); |
455328d90876
7029458: G1: Add newly-reclaimed regions to the beginning of the region free list, not the end
tonyp
parents:
2361
diff
changeset
|
127 } |
455328d90876
7029458: G1: Add newly-reclaimed regions to the beginning of the region free list, not the end
tonyp
parents:
2361
diff
changeset
|
128 #endif // ASSERT |
455328d90876
7029458: G1: Add newly-reclaimed regions to the beginning of the region free list, not the end
tonyp
parents:
2361
diff
changeset
|
129 |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
130 if (_head == NULL) { |
6252
d42fe3c3001d
7184772: G1: Incorrect assert in HeapRegionLinkedList::add_as_head()
johnc
parents:
6010
diff
changeset
|
131 assert(length() == 0 && _tail == NULL, hrs_ext_msg(this, "invariant")); |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
132 _head = from_list->_head; |
2432
455328d90876
7029458: G1: Add newly-reclaimed regions to the beginning of the region free list, not the end
tonyp
parents:
2361
diff
changeset
|
133 _tail = from_list->_tail; |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
134 } else { |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
135 assert(length() > 0 && _tail != NULL, hrs_ext_msg(this, "invariant")); |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
136 if (as_head) { |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
137 from_list->_tail->set_next(_head); |
17773
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
138 _head->set_prev(from_list->_tail); |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
139 _head = from_list->_head; |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
140 } else { |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
141 _tail->set_next(from_list->_head); |
17773
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
142 from_list->_head->set_prev(_tail); |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
143 _tail = from_list->_tail; |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
144 } |
2432
455328d90876
7029458: G1: Add newly-reclaimed regions to the beginning of the region free list, not the end
tonyp
parents:
2361
diff
changeset
|
145 } |
455328d90876
7029458: G1: Add newly-reclaimed regions to the beginning of the region free list, not the end
tonyp
parents:
2361
diff
changeset
|
146 |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
147 _count.increment(from_list->length(), from_list->total_capacity_bytes()); |
2432
455328d90876
7029458: G1: Add newly-reclaimed regions to the beginning of the region free list, not the end
tonyp
parents:
2361
diff
changeset
|
148 from_list->clear(); |
455328d90876
7029458: G1: Add newly-reclaimed regions to the beginning of the region free list, not the end
tonyp
parents:
2361
diff
changeset
|
149 |
455328d90876
7029458: G1: Add newly-reclaimed regions to the beginning of the region free list, not the end
tonyp
parents:
2361
diff
changeset
|
150 verify_optional(); |
455328d90876
7029458: G1: Add newly-reclaimed regions to the beginning of the region free list, not the end
tonyp
parents:
2361
diff
changeset
|
151 from_list->verify_optional(); |
455328d90876
7029458: G1: Add newly-reclaimed regions to the beginning of the region free list, not the end
tonyp
parents:
2361
diff
changeset
|
152 } |
455328d90876
7029458: G1: Add newly-reclaimed regions to the beginning of the region free list, not the end
tonyp
parents:
2361
diff
changeset
|
153 |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
154 void FreeRegionList::add_as_head(FreeRegionList* from_list) { |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
155 add_as_head_or_tail(from_list, true /* as_head */); |
2152 | 156 } |
157 | |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
158 void FreeRegionList::add_as_tail(FreeRegionList* from_list) { |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
159 add_as_head_or_tail(from_list, false /* as_head */); |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
160 } |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
161 |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
162 void FreeRegionList::remove_all() { |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
163 check_mt_safety(); |
2152 | 164 verify_optional(); |
165 | |
166 HeapRegion* curr = _head; | |
167 while (curr != NULL) { | |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
168 verify_region(curr); |
2152 | 169 |
170 HeapRegion* next = curr->next(); | |
171 curr->set_next(NULL); | |
17773
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
172 curr->set_prev(NULL); |
2152 | 173 curr->set_containing_set(NULL); |
174 curr = next; | |
175 } | |
176 clear(); | |
177 | |
178 verify_optional(); | |
179 } | |
180 | |
17773
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
181 void FreeRegionList::add_ordered(FreeRegionList* from_list) { |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
182 check_mt_safety(); |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
183 from_list->check_mt_safety(); |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
184 |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
185 verify_optional(); |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
186 from_list->verify_optional(); |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
187 |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
188 if (from_list->is_empty()) { |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
189 return; |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
190 } |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
191 |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
192 if (is_empty()) { |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
193 add_as_head(from_list); |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
194 return; |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
195 } |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
196 |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
197 #ifdef ASSERT |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
198 FreeRegionListIterator iter(from_list); |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
199 while (iter.more_available()) { |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
200 HeapRegion* hr = iter.get_next(); |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
201 // In set_containing_set() we check that we either set the value |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
202 // from NULL to non-NULL or vice versa to catch bugs. So, we have |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
203 // to NULL it first before setting it to the value. |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
204 hr->set_containing_set(NULL); |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
205 hr->set_containing_set(this); |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
206 } |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
207 #endif // ASSERT |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
208 |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
209 HeapRegion* curr_to = _head; |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
210 HeapRegion* curr_from = from_list->_head; |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
211 |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
212 while (curr_from != NULL) { |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
213 while (curr_to != NULL && curr_to->hrs_index() < curr_from->hrs_index()) { |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
214 curr_to = curr_to->next(); |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
215 } |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
216 |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
217 if (curr_to == NULL) { |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
218 // The rest of the from list should be added as tail |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
219 _tail->set_next(curr_from); |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
220 curr_from->set_prev(_tail); |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
221 curr_from = NULL; |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
222 } else { |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
223 HeapRegion* next_from = curr_from->next(); |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
224 |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
225 curr_from->set_next(curr_to); |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
226 curr_from->set_prev(curr_to->prev()); |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
227 if (curr_to->prev() == NULL) { |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
228 _head = curr_from; |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
229 } else { |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
230 curr_to->prev()->set_next(curr_from); |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
231 } |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
232 curr_to->set_prev(curr_from); |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
233 |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
234 curr_from = next_from; |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
235 } |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
236 } |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
237 |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
238 if (_tail->hrs_index() < from_list->_tail->hrs_index()) { |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
239 _tail = from_list->_tail; |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
240 } |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
241 |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
242 _count.increment(from_list->length(), from_list->total_capacity_bytes()); |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
243 from_list->clear(); |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
244 |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
245 verify_optional(); |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
246 from_list->verify_optional(); |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
247 } |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
248 |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
249 void FreeRegionList::remove_all_pending(uint target_count) { |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
250 check_mt_safety(); |
2361 | 251 assert(target_count > 1, hrs_ext_msg(this, "pre-condition")); |
252 assert(!is_empty(), hrs_ext_msg(this, "pre-condition")); | |
2152 | 253 |
254 verify_optional(); | |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
4072
diff
changeset
|
255 DEBUG_ONLY(uint old_length = length();) |
2152 | 256 |
257 HeapRegion* curr = _head; | |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
4072
diff
changeset
|
258 uint count = 0; |
2152 | 259 while (curr != NULL) { |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
260 verify_region(curr); |
2152 | 261 HeapRegion* next = curr->next(); |
17773
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
262 HeapRegion* prev = curr->prev(); |
2152 | 263 |
264 if (curr->pending_removal()) { | |
265 assert(count < target_count, | |
2361 | 266 hrs_err_msg("[%s] should not come across more regions " |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
4072
diff
changeset
|
267 "pending for removal than target_count: %u", |
2152 | 268 name(), target_count)); |
269 | |
270 if (prev == NULL) { | |
2361 | 271 assert(_head == curr, hrs_ext_msg(this, "invariant")); |
2152 | 272 _head = next; |
273 } else { | |
2361 | 274 assert(_head != curr, hrs_ext_msg(this, "invariant")); |
2152 | 275 prev->set_next(next); |
276 } | |
277 if (next == NULL) { | |
2361 | 278 assert(_tail == curr, hrs_ext_msg(this, "invariant")); |
2152 | 279 _tail = prev; |
280 } else { | |
2361 | 281 assert(_tail != curr, hrs_ext_msg(this, "invariant")); |
17773
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
282 next->set_prev(prev); |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
283 } |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
284 if (_last = curr) { |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
285 _last = NULL; |
2152 | 286 } |
287 | |
288 curr->set_next(NULL); | |
17773
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
289 curr->set_prev(NULL); |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
290 remove(curr); |
2152 | 291 curr->set_pending_removal(false); |
292 | |
293 count += 1; | |
294 | |
295 // If we have come across the target number of regions we can | |
296 // just bail out. However, for debugging purposes, we can just | |
297 // carry on iterating to make sure there are not more regions | |
298 // tagged with pending removal. | |
299 DEBUG_ONLY(if (count == target_count) break;) | |
300 } | |
301 curr = next; | |
302 } | |
303 | |
304 assert(count == target_count, | |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
4072
diff
changeset
|
305 hrs_err_msg("[%s] count: %u should be == target_count: %u", |
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
4072
diff
changeset
|
306 name(), count, target_count)); |
2152 | 307 assert(length() + target_count == old_length, |
2361 | 308 hrs_err_msg("[%s] new length should be consistent " |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
4072
diff
changeset
|
309 "new length: %u old length: %u target_count: %u", |
2152 | 310 name(), length(), old_length, target_count)); |
311 | |
312 verify_optional(); | |
313 } | |
314 | |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
315 void FreeRegionList::verify() { |
2152 | 316 // See comment in HeapRegionSetBase::verify() about MT safety and |
317 // verification. | |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
318 check_mt_safety(); |
2152 | 319 |
320 // This will also do the basic verification too. | |
321 verify_start(); | |
322 | |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
323 verify_list(); |
2152 | 324 |
325 verify_end(); | |
326 } | |
327 | |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
328 void FreeRegionList::clear() { |
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
329 _count = HeapRegionSetCount(); |
2152 | 330 _head = NULL; |
331 _tail = NULL; | |
17773
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
332 _last = NULL; |
2152 | 333 } |
334 | |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
335 void FreeRegionList::print_on(outputStream* out, bool print_contents) { |
2152 | 336 HeapRegionSetBase::print_on(out, print_contents); |
337 out->print_cr(" Linking"); | |
338 out->print_cr(" head : "PTR_FORMAT, _head); | |
339 out->print_cr(" tail : "PTR_FORMAT, _tail); | |
340 | |
341 if (print_contents) { | |
342 out->print_cr(" Contents"); | |
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
6254
diff
changeset
|
343 FreeRegionListIterator iter(this); |
2152 | 344 while (iter.more_available()) { |
345 HeapRegion* hr = iter.get_next(); | |
346 hr->print_on(out); | |
347 } | |
348 } | |
349 } | |
17737 | 350 |
351 void FreeRegionList::verify_list() { | |
352 HeapRegion* curr = head(); | |
353 HeapRegion* prev1 = NULL; | |
354 HeapRegion* prev0 = NULL; | |
355 uint count = 0; | |
356 size_t capacity = 0; | |
17773
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
357 uint last_index = 0; |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
358 |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
359 guarantee(_head == NULL || _head->prev() == NULL, "_head should not have a prev"); |
17737 | 360 while (curr != NULL) { |
361 verify_region(curr); | |
362 | |
363 count++; | |
364 guarantee(count < _unrealistically_long_length, | |
365 hrs_err_msg("[%s] the calculated length: %u seems very long, is there maybe a cycle? curr: "PTR_FORMAT" prev0: "PTR_FORMAT" " "prev1: "PTR_FORMAT" length: %u", name(), count, curr, prev0, prev1, length())); | |
366 | |
17773
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
367 if (curr->next() != NULL) { |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
368 guarantee(curr->next()->prev() == curr, "Next or prev pointers messed up"); |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
369 } |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
370 guarantee(curr->hrs_index() == 0 || curr->hrs_index() > last_index, "List should be sorted"); |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
371 last_index = curr->hrs_index(); |
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
372 |
17737 | 373 capacity += curr->capacity(); |
374 | |
375 prev1 = prev0; | |
376 prev0 = curr; | |
377 curr = curr->next(); | |
378 } | |
379 | |
380 guarantee(tail() == prev0, err_msg("Expected %s to end with %u but it ended with %u.", name(), tail()->hrs_index(), prev0->hrs_index())); | |
17773
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17737
diff
changeset
|
381 guarantee(_tail == NULL || _tail->next() == NULL, "_tail should not have a next"); |
17737 | 382 guarantee(length() == count, err_msg("%s count mismatch. Expected %u, actual %u.", name(), length(), count)); |
383 guarantee(total_capacity_bytes() == capacity, err_msg("%s capacity mismatch. Expected " SIZE_FORMAT ", actual " SIZE_FORMAT, | |
384 name(), total_capacity_bytes(), capacity)); | |
385 } | |
386 | |
387 // Note on the check_mt_safety() methods below: | |
388 // | |
389 // Verification of the "master" heap region sets / lists that are | |
390 // maintained by G1CollectedHeap is always done during a STW pause and | |
391 // by the VM thread at the start / end of the pause. The standard | |
392 // verification methods all assert check_mt_safety(). This is | |
393 // important as it ensures that verification is done without | |
394 // concurrent updates taking place at the same time. It follows, that, | |
395 // for the "master" heap region sets / lists, the check_mt_safety() | |
396 // method should include the VM thread / STW case. | |
397 | |
398 void MasterFreeRegionListMtSafeChecker::check() { | |
399 // Master Free List MT safety protocol: | |
400 // (a) If we're at a safepoint, operations on the master free list | |
401 // should be invoked by either the VM thread (which will serialize | |
402 // them) or by the GC workers while holding the | |
403 // FreeList_lock. | |
404 // (b) If we're not at a safepoint, operations on the master free | |
405 // list should be invoked while holding the Heap_lock. | |
406 | |
407 if (SafepointSynchronize::is_at_safepoint()) { | |
408 guarantee(Thread::current()->is_VM_thread() || | |
409 FreeList_lock->owned_by_self(), "master free list MT safety protocol at a safepoint"); | |
410 } else { | |
411 guarantee(Heap_lock->owned_by_self(), "master free list MT safety protocol outside a safepoint"); | |
412 } | |
413 } | |
414 | |
415 void SecondaryFreeRegionListMtSafeChecker::check() { | |
416 // Secondary Free List MT safety protocol: | |
417 // Operations on the secondary free list should always be invoked | |
418 // while holding the SecondaryFreeList_lock. | |
419 | |
420 guarantee(SecondaryFreeList_lock->owned_by_self(), "secondary free list MT safety protocol"); | |
421 } | |
422 | |
423 void OldRegionSetMtSafeChecker::check() { | |
424 // Master Old Set MT safety protocol: | |
425 // (a) If we're at a safepoint, operations on the master old set | |
426 // should be invoked: | |
427 // - by the VM thread (which will serialize them), or | |
428 // - by the GC workers while holding the FreeList_lock, if we're | |
429 // at a safepoint for an evacuation pause (this lock is taken | |
430 // anyway when an GC alloc region is retired so that a new one | |
431 // is allocated from the free list), or | |
432 // - by the GC workers while holding the OldSets_lock, if we're at a | |
433 // safepoint for a cleanup pause. | |
434 // (b) If we're not at a safepoint, operations on the master old set | |
435 // should be invoked while holding the Heap_lock. | |
436 | |
437 if (SafepointSynchronize::is_at_safepoint()) { | |
438 guarantee(Thread::current()->is_VM_thread() | |
439 || FreeList_lock->owned_by_self() || OldSets_lock->owned_by_self(), | |
440 "master old set MT safety protocol at a safepoint"); | |
441 } else { | |
442 guarantee(Heap_lock->owned_by_self(), "master old set MT safety protocol outside a safepoint"); | |
443 } | |
444 } | |
445 | |
446 void HumongousRegionSetMtSafeChecker::check() { | |
447 // Humongous Set MT safety protocol: | |
448 // (a) If we're at a safepoint, operations on the master humongous | |
449 // set should be invoked by either the VM thread (which will | |
450 // serialize them) or by the GC workers while holding the | |
451 // OldSets_lock. | |
452 // (b) If we're not at a safepoint, operations on the master | |
453 // humongous set should be invoked while holding the Heap_lock. | |
454 | |
455 if (SafepointSynchronize::is_at_safepoint()) { | |
456 guarantee(Thread::current()->is_VM_thread() || | |
457 OldSets_lock->owned_by_self(), | |
458 "master humongous set MT safety protocol at a safepoint"); | |
459 } else { | |
460 guarantee(Heap_lock->owned_by_self(), | |
461 "master humongous set MT safety protocol outside a safepoint"); | |
462 } | |
463 } |