author | sangheki |
Wed, 13 Nov 2019 10:51:41 -0800 | |
changeset 59062 | 6530de931b8e |
parent 53116 | bb03098c4dde |
permissions | -rw-r--r-- |
7923 | 1 |
/* |
59062
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
2 |
* Copyright (c) 2011, 2019, Oracle and/or its affiliates. All rights reserved. |
7923 | 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" |
|
30764 | 26 |
#include "gc/g1/g1CollectedHeap.inline.hpp" |
59062
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
27 |
#include "gc/g1/g1NUMA.hpp" |
30764 | 28 |
#include "gc/g1/heapRegionRemSet.hpp" |
29 |
#include "gc/g1/heapRegionSet.inline.hpp" |
|
7923 | 30 |
|
23450
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
13336
diff
changeset
|
31 |
uint FreeRegionList::_unrealistically_long_length = 0; |
7923 | 32 |
|
23450
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
13336
diff
changeset
|
33 |
#ifndef PRODUCT |
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
13336
diff
changeset
|
34 |
void HeapRegionSetBase::verify_region(HeapRegion* hr) { |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31592
diff
changeset
|
35 |
assert(hr->containing_set() == this, "Inconsistent containing set for %u", hr->hrm_index()); |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31592
diff
changeset
|
36 |
assert(!hr->is_young(), "Adding young region %u", hr->hrm_index()); // currently we don't use these sets for young regions |
51496
bf6b66fa8bdf
8209700: Remove HeapRegionSetBase::RegionSetKind for a more flexible approach
tschatzl
parents:
51494
diff
changeset
|
37 |
assert(_checker == NULL || _checker->is_correct_type(hr), "Wrong type of region %u (%s) and set %s", |
bf6b66fa8bdf
8209700: Remove HeapRegionSetBase::RegionSetKind for a more flexible approach
tschatzl
parents:
51494
diff
changeset
|
38 |
hr->hrm_index(), hr->get_type_str(), name()); |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31592
diff
changeset
|
39 |
assert(!hr->is_free() || hr->is_empty(), "Free region %u is not empty for set %s", hr->hrm_index(), name()); |
31346
a70d45c06136
8042668: GC Support for shared heap ranges in CDS
jiangli
parents:
30764
diff
changeset
|
40 |
assert(!hr->is_empty() || hr->is_free() || hr->is_archive(), |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31592
diff
changeset
|
41 |
"Empty region %u is not free or archive for set %s", hr->hrm_index(), name()); |
7923 | 42 |
} |
23450
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
13336
diff
changeset
|
43 |
#endif |
7923 | 44 |
|
45 |
void HeapRegionSetBase::verify() { |
|
46 |
// It's important that we also observe the MT safety protocol even |
|
47 |
// for the verification calls. If we do verification without the |
|
48 |
// appropriate locks and the set changes underneath our feet |
|
49 |
// verification might fail and send us on a wild goose chase. |
|
23450
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
13336
diff
changeset
|
50 |
check_mt_safety(); |
7923 | 51 |
|
35065
b4ff0249c092
8144996: Replace the HeapRegionSetCount class with an uint
david
parents:
35061
diff
changeset
|
52 |
guarantee_heap_region_set(( is_empty() && length() == 0) || |
b4ff0249c092
8144996: Replace the HeapRegionSetCount class with an uint
david
parents:
35061
diff
changeset
|
53 |
(!is_empty() && length() > 0), |
33753
3add06d0880f
8137756: Remove hrs_err_msg and hrs_ext_msg from heapRegionSet
david
parents:
33752
diff
changeset
|
54 |
"invariant"); |
7923 | 55 |
} |
56 |
||
57 |
void HeapRegionSetBase::verify_start() { |
|
58 |
// See comment in verify() about MT safety and verification. |
|
23450
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
13336
diff
changeset
|
59 |
check_mt_safety(); |
33753
3add06d0880f
8137756: Remove hrs_err_msg and hrs_ext_msg from heapRegionSet
david
parents:
33752
diff
changeset
|
60 |
assert_heap_region_set(!_verify_in_progress, "verification should not be in progress"); |
7923 | 61 |
|
62 |
// Do the basic verification first before we do the checks over the regions. |
|
63 |
HeapRegionSetBase::verify(); |
|
64 |
||
26157
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
65 |
_verify_in_progress = true; |
7923 | 66 |
} |
67 |
||
68 |
void HeapRegionSetBase::verify_end() { |
|
69 |
// See comment in verify() about MT safety and verification. |
|
23450
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
13336
diff
changeset
|
70 |
check_mt_safety(); |
33753
3add06d0880f
8137756: Remove hrs_err_msg and hrs_ext_msg from heapRegionSet
david
parents:
33752
diff
changeset
|
71 |
assert_heap_region_set(_verify_in_progress, "verification should be in progress"); |
7923 | 72 |
|
73 |
_verify_in_progress = false; |
|
74 |
} |
|
75 |
||
76 |
void HeapRegionSetBase::print_on(outputStream* out, bool print_contents) { |
|
77 |
out->cr(); |
|
31592
43f48e165466
8081202: Hotspot compile warning: "Invalid suffix on literal; C++11 requires a space between literal and identifier"
bpittore
parents:
31346
diff
changeset
|
78 |
out->print_cr("Set: %s (" PTR_FORMAT ")", name(), p2i(this)); |
51496
bf6b66fa8bdf
8209700: Remove HeapRegionSetBase::RegionSetKind for a more flexible approach
tschatzl
parents:
51494
diff
changeset
|
79 |
out->print_cr(" Region Type : %s", _checker->get_description()); |
bf6b66fa8bdf
8209700: Remove HeapRegionSetBase::RegionSetKind for a more flexible approach
tschatzl
parents:
51494
diff
changeset
|
80 |
out->print_cr(" Length : %14u", length()); |
7923 | 81 |
} |
82 |
||
51496
bf6b66fa8bdf
8209700: Remove HeapRegionSetBase::RegionSetKind for a more flexible approach
tschatzl
parents:
51494
diff
changeset
|
83 |
HeapRegionSetBase::HeapRegionSetBase(const char* name, HeapRegionSetChecker* checker) |
bf6b66fa8bdf
8209700: Remove HeapRegionSetBase::RegionSetKind for a more flexible approach
tschatzl
parents:
51494
diff
changeset
|
84 |
: _checker(checker), _length(0), _name(name), _verify_in_progress(false) |
51494
1906adbef2dc
8208498: Put archive regions into a first-class HeapRegionSet
tschatzl
parents:
51332
diff
changeset
|
85 |
{ |
1906adbef2dc
8208498: Put archive regions into a first-class HeapRegionSet
tschatzl
parents:
51332
diff
changeset
|
86 |
} |
7923 | 87 |
|
23450
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
13336
diff
changeset
|
88 |
void FreeRegionList::set_unrealistically_long_length(uint len) { |
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
13336
diff
changeset
|
89 |
guarantee(_unrealistically_long_length == 0, "should only be set once"); |
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
13336
diff
changeset
|
90 |
_unrealistically_long_length = len; |
7923 | 91 |
} |
92 |
||
23450
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
13336
diff
changeset
|
93 |
void FreeRegionList::remove_all() { |
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
13336
diff
changeset
|
94 |
check_mt_safety(); |
7923 | 95 |
verify_optional(); |
96 |
||
97 |
HeapRegion* curr = _head; |
|
98 |
while (curr != NULL) { |
|
23450
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
13336
diff
changeset
|
99 |
verify_region(curr); |
7923 | 100 |
|
101 |
HeapRegion* next = curr->next(); |
|
102 |
curr->set_next(NULL); |
|
23471
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
103 |
curr->set_prev(NULL); |
7923 | 104 |
curr->set_containing_set(NULL); |
59062
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
105 |
|
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
106 |
decrease_length(curr->node_index()); |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
107 |
|
7923 | 108 |
curr = next; |
109 |
} |
|
110 |
clear(); |
|
111 |
||
112 |
verify_optional(); |
|
113 |
} |
|
114 |
||
23471
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
115 |
void FreeRegionList::add_ordered(FreeRegionList* from_list) { |
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
116 |
check_mt_safety(); |
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
117 |
from_list->check_mt_safety(); |
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
118 |
|
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
119 |
verify_optional(); |
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
120 |
from_list->verify_optional(); |
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
121 |
|
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
122 |
if (from_list->is_empty()) { |
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
123 |
return; |
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
124 |
} |
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
125 |
|
59062
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
126 |
if (_node_info != NULL && from_list->_node_info != NULL) { |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
127 |
_node_info->add(from_list->_node_info); |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
128 |
} |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
129 |
|
23471
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
130 |
#ifdef ASSERT |
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
131 |
FreeRegionListIterator iter(from_list); |
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
132 |
while (iter.more_available()) { |
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
133 |
HeapRegion* hr = iter.get_next(); |
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
134 |
// In set_containing_set() we check that we either set the value |
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
135 |
// from NULL to non-NULL or vice versa to catch bugs. So, we have |
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
136 |
// to NULL it first before setting it to the value. |
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
137 |
hr->set_containing_set(NULL); |
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
138 |
hr->set_containing_set(this); |
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
139 |
} |
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
140 |
#endif // ASSERT |
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
141 |
|
26157
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
142 |
if (is_empty()) { |
33753
3add06d0880f
8137756: Remove hrs_err_msg and hrs_ext_msg from heapRegionSet
david
parents:
33752
diff
changeset
|
143 |
assert_free_region_list(length() == 0 && _tail == NULL, "invariant"); |
26157
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
144 |
_head = from_list->_head; |
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
145 |
_tail = from_list->_tail; |
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
146 |
} else { |
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
147 |
HeapRegion* curr_to = _head; |
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
148 |
HeapRegion* curr_from = from_list->_head; |
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
149 |
|
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
150 |
while (curr_from != NULL) { |
26316
93f6b40c038b
8054819: Rename HeapRegionSeq to HeapRegionManager
tschatzl
parents:
26160
diff
changeset
|
151 |
while (curr_to != NULL && curr_to->hrm_index() < curr_from->hrm_index()) { |
26157
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
152 |
curr_to = curr_to->next(); |
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
153 |
} |
23471
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
154 |
|
26157
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
155 |
if (curr_to == NULL) { |
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
156 |
// The rest of the from list should be added as tail |
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
157 |
_tail->set_next(curr_from); |
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
158 |
curr_from->set_prev(_tail); |
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
159 |
curr_from = NULL; |
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
160 |
} else { |
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
161 |
HeapRegion* next_from = curr_from->next(); |
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
162 |
|
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
163 |
curr_from->set_next(curr_to); |
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
164 |
curr_from->set_prev(curr_to->prev()); |
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
165 |
if (curr_to->prev() == NULL) { |
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
166 |
_head = curr_from; |
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
167 |
} else { |
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
168 |
curr_to->prev()->set_next(curr_from); |
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
169 |
} |
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
170 |
curr_to->set_prev(curr_from); |
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
171 |
|
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
172 |
curr_from = next_from; |
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
173 |
} |
23471
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
174 |
} |
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
175 |
|
26316
93f6b40c038b
8054819: Rename HeapRegionSeq to HeapRegionManager
tschatzl
parents:
26160
diff
changeset
|
176 |
if (_tail->hrm_index() < from_list->_tail->hrm_index()) { |
26157
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
177 |
_tail = from_list->_tail; |
23471
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
178 |
} |
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
179 |
} |
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
180 |
|
35065
b4ff0249c092
8144996: Replace the HeapRegionSetCount class with an uint
david
parents:
35061
diff
changeset
|
181 |
_length += from_list->length(); |
23471
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
182 |
from_list->clear(); |
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
183 |
|
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
184 |
verify_optional(); |
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
185 |
from_list->verify_optional(); |
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
186 |
} |
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
187 |
|
26157
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
188 |
void FreeRegionList::remove_starting_at(HeapRegion* first, uint num_regions) { |
23450
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
13336
diff
changeset
|
189 |
check_mt_safety(); |
33753
3add06d0880f
8137756: Remove hrs_err_msg and hrs_ext_msg from heapRegionSet
david
parents:
33752
diff
changeset
|
190 |
assert_free_region_list(num_regions >= 1, "pre-condition"); |
3add06d0880f
8137756: Remove hrs_err_msg and hrs_ext_msg from heapRegionSet
david
parents:
33752
diff
changeset
|
191 |
assert_free_region_list(!is_empty(), "pre-condition"); |
7923 | 192 |
|
193 |
verify_optional(); |
|
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
10996
diff
changeset
|
194 |
DEBUG_ONLY(uint old_length = length();) |
7923 | 195 |
|
26157
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
196 |
HeapRegion* curr = first; |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
10996
diff
changeset
|
197 |
uint count = 0; |
26157
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
198 |
while (count < num_regions) { |
23450
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
13336
diff
changeset
|
199 |
verify_region(curr); |
7923 | 200 |
HeapRegion* next = curr->next(); |
23471
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
201 |
HeapRegion* prev = curr->prev(); |
7923 | 202 |
|
26157
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
203 |
assert(count < num_regions, |
33753
3add06d0880f
8137756: Remove hrs_err_msg and hrs_ext_msg from heapRegionSet
david
parents:
33752
diff
changeset
|
204 |
"[%s] should not come across more regions " |
3add06d0880f
8137756: Remove hrs_err_msg and hrs_ext_msg from heapRegionSet
david
parents:
33752
diff
changeset
|
205 |
"pending for removal than num_regions: %u", |
3add06d0880f
8137756: Remove hrs_err_msg and hrs_ext_msg from heapRegionSet
david
parents:
33752
diff
changeset
|
206 |
name(), num_regions); |
7923 | 207 |
|
26157
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
208 |
if (prev == NULL) { |
33753
3add06d0880f
8137756: Remove hrs_err_msg and hrs_ext_msg from heapRegionSet
david
parents:
33752
diff
changeset
|
209 |
assert_free_region_list(_head == curr, "invariant"); |
26157
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
210 |
_head = next; |
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
211 |
} else { |
33753
3add06d0880f
8137756: Remove hrs_err_msg and hrs_ext_msg from heapRegionSet
david
parents:
33752
diff
changeset
|
212 |
assert_free_region_list(_head != curr, "invariant"); |
26157
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
213 |
prev->set_next(next); |
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
214 |
} |
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
215 |
if (next == NULL) { |
33753
3add06d0880f
8137756: Remove hrs_err_msg and hrs_ext_msg from heapRegionSet
david
parents:
33752
diff
changeset
|
216 |
assert_free_region_list(_tail == curr, "invariant"); |
26157
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
217 |
_tail = prev; |
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
218 |
} else { |
33753
3add06d0880f
8137756: Remove hrs_err_msg and hrs_ext_msg from heapRegionSet
david
parents:
33752
diff
changeset
|
219 |
assert_free_region_list(_tail != curr, "invariant"); |
26157
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
220 |
next->set_prev(prev); |
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
221 |
} |
33752 | 222 |
if (_last == curr) { |
26157
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
223 |
_last = NULL; |
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
224 |
} |
7923 | 225 |
|
26157
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
226 |
curr->set_next(NULL); |
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
227 |
curr->set_prev(NULL); |
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
228 |
remove(curr); |
7923 | 229 |
|
26157
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
230 |
count++; |
59062
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
231 |
|
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
232 |
decrease_length(curr->node_index()); |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
233 |
|
7923 | 234 |
curr = next; |
235 |
} |
|
236 |
||
26157
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
237 |
assert(count == num_regions, |
33753
3add06d0880f
8137756: Remove hrs_err_msg and hrs_ext_msg from heapRegionSet
david
parents:
33752
diff
changeset
|
238 |
"[%s] count: %u should be == num_regions: %u", |
3add06d0880f
8137756: Remove hrs_err_msg and hrs_ext_msg from heapRegionSet
david
parents:
33752
diff
changeset
|
239 |
name(), count, num_regions); |
26157
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
240 |
assert(length() + num_regions == old_length, |
33753
3add06d0880f
8137756: Remove hrs_err_msg and hrs_ext_msg from heapRegionSet
david
parents:
33752
diff
changeset
|
241 |
"[%s] new length should be consistent " |
3add06d0880f
8137756: Remove hrs_err_msg and hrs_ext_msg from heapRegionSet
david
parents:
33752
diff
changeset
|
242 |
"new length: %u old length: %u num_regions: %u", |
3add06d0880f
8137756: Remove hrs_err_msg and hrs_ext_msg from heapRegionSet
david
parents:
33752
diff
changeset
|
243 |
name(), length(), old_length, num_regions); |
7923 | 244 |
|
245 |
verify_optional(); |
|
246 |
} |
|
247 |
||
53116
bb03098c4dde
8211425: Allocation of old generation of java heap on alternate memory devices - G1 GC
sangheki
parents:
51496
diff
changeset
|
248 |
uint FreeRegionList::num_of_regions_in_range(uint start, uint end) const { |
bb03098c4dde
8211425: Allocation of old generation of java heap on alternate memory devices - G1 GC
sangheki
parents:
51496
diff
changeset
|
249 |
HeapRegion* cur = _head; |
bb03098c4dde
8211425: Allocation of old generation of java heap on alternate memory devices - G1 GC
sangheki
parents:
51496
diff
changeset
|
250 |
uint num = 0; |
bb03098c4dde
8211425: Allocation of old generation of java heap on alternate memory devices - G1 GC
sangheki
parents:
51496
diff
changeset
|
251 |
while (cur != NULL) { |
bb03098c4dde
8211425: Allocation of old generation of java heap on alternate memory devices - G1 GC
sangheki
parents:
51496
diff
changeset
|
252 |
uint index = cur->hrm_index(); |
bb03098c4dde
8211425: Allocation of old generation of java heap on alternate memory devices - G1 GC
sangheki
parents:
51496
diff
changeset
|
253 |
if (index > end) { |
bb03098c4dde
8211425: Allocation of old generation of java heap on alternate memory devices - G1 GC
sangheki
parents:
51496
diff
changeset
|
254 |
break; |
bb03098c4dde
8211425: Allocation of old generation of java heap on alternate memory devices - G1 GC
sangheki
parents:
51496
diff
changeset
|
255 |
} else if (index >= start) { |
bb03098c4dde
8211425: Allocation of old generation of java heap on alternate memory devices - G1 GC
sangheki
parents:
51496
diff
changeset
|
256 |
num++; |
bb03098c4dde
8211425: Allocation of old generation of java heap on alternate memory devices - G1 GC
sangheki
parents:
51496
diff
changeset
|
257 |
} |
bb03098c4dde
8211425: Allocation of old generation of java heap on alternate memory devices - G1 GC
sangheki
parents:
51496
diff
changeset
|
258 |
cur = cur->next(); |
bb03098c4dde
8211425: Allocation of old generation of java heap on alternate memory devices - G1 GC
sangheki
parents:
51496
diff
changeset
|
259 |
} |
bb03098c4dde
8211425: Allocation of old generation of java heap on alternate memory devices - G1 GC
sangheki
parents:
51496
diff
changeset
|
260 |
return num; |
bb03098c4dde
8211425: Allocation of old generation of java heap on alternate memory devices - G1 GC
sangheki
parents:
51496
diff
changeset
|
261 |
} |
bb03098c4dde
8211425: Allocation of old generation of java heap on alternate memory devices - G1 GC
sangheki
parents:
51496
diff
changeset
|
262 |
|
23450
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
13336
diff
changeset
|
263 |
void FreeRegionList::verify() { |
7923 | 264 |
// See comment in HeapRegionSetBase::verify() about MT safety and |
265 |
// verification. |
|
23450
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
13336
diff
changeset
|
266 |
check_mt_safety(); |
7923 | 267 |
|
268 |
// This will also do the basic verification too. |
|
269 |
verify_start(); |
|
270 |
||
23450
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
13336
diff
changeset
|
271 |
verify_list(); |
7923 | 272 |
|
273 |
verify_end(); |
|
274 |
} |
|
275 |
||
23450
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
13336
diff
changeset
|
276 |
void FreeRegionList::clear() { |
35065
b4ff0249c092
8144996: Replace the HeapRegionSetCount class with an uint
david
parents:
35061
diff
changeset
|
277 |
_length = 0; |
7923 | 278 |
_head = NULL; |
279 |
_tail = NULL; |
|
23471
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
280 |
_last = NULL; |
59062
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
281 |
|
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
282 |
if (_node_info!= NULL) { |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
283 |
_node_info->clear(); |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
284 |
} |
7923 | 285 |
} |
286 |
||
23459 | 287 |
void FreeRegionList::verify_list() { |
26157
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
24424
diff
changeset
|
288 |
HeapRegion* curr = _head; |
23459 | 289 |
HeapRegion* prev1 = NULL; |
290 |
HeapRegion* prev0 = NULL; |
|
291 |
uint count = 0; |
|
292 |
size_t capacity = 0; |
|
23471
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
293 |
uint last_index = 0; |
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
294 |
|
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
295 |
guarantee(_head == NULL || _head->prev() == NULL, "_head should not have a prev"); |
23459 | 296 |
while (curr != NULL) { |
297 |
verify_region(curr); |
|
298 |
||
299 |
count++; |
|
300 |
guarantee(count < _unrealistically_long_length, |
|
33753
3add06d0880f
8137756: Remove hrs_err_msg and hrs_ext_msg from heapRegionSet
david
parents:
33752
diff
changeset
|
301 |
"[%s] the calculated length: %u seems very long, is there maybe a cycle? curr: " PTR_FORMAT " prev0: " PTR_FORMAT " " "prev1: " PTR_FORMAT " length: %u", |
3add06d0880f
8137756: Remove hrs_err_msg and hrs_ext_msg from heapRegionSet
david
parents:
33752
diff
changeset
|
302 |
name(), count, p2i(curr), p2i(prev0), p2i(prev1), length()); |
23459 | 303 |
|
23471
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
304 |
if (curr->next() != NULL) { |
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
305 |
guarantee(curr->next()->prev() == curr, "Next or prev pointers messed up"); |
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
306 |
} |
26316
93f6b40c038b
8054819: Rename HeapRegionSeq to HeapRegionManager
tschatzl
parents:
26160
diff
changeset
|
307 |
guarantee(curr->hrm_index() == 0 || curr->hrm_index() > last_index, "List should be sorted"); |
93f6b40c038b
8054819: Rename HeapRegionSeq to HeapRegionManager
tschatzl
parents:
26160
diff
changeset
|
308 |
last_index = curr->hrm_index(); |
23471
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
309 |
|
23459 | 310 |
capacity += curr->capacity(); |
311 |
||
312 |
prev1 = prev0; |
|
313 |
prev0 = curr; |
|
314 |
curr = curr->next(); |
|
315 |
} |
|
316 |
||
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31592
diff
changeset
|
317 |
guarantee(_tail == prev0, "Expected %s to end with %u but it ended with %u.", name(), _tail->hrm_index(), prev0->hrm_index()); |
23471
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23459
diff
changeset
|
318 |
guarantee(_tail == NULL || _tail->next() == NULL, "_tail should not have a next"); |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31592
diff
changeset
|
319 |
guarantee(length() == count, "%s count mismatch. Expected %u, actual %u.", name(), length(), count); |
23459 | 320 |
} |
59062
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
321 |
|
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
322 |
|
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
323 |
FreeRegionList::FreeRegionList(const char* name, HeapRegionSetChecker* checker): |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
324 |
HeapRegionSetBase(name, checker), |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
325 |
_node_info(G1NUMA::numa()->is_enabled() ? new NodeInfo() : NULL) { |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
326 |
|
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
327 |
clear(); |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
328 |
} |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
329 |
|
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
330 |
FreeRegionList::~FreeRegionList() { |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
331 |
if (_node_info != NULL) { |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
332 |
delete _node_info; |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
333 |
} |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
334 |
} |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
335 |
|
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
336 |
FreeRegionList::NodeInfo::NodeInfo() : _numa(G1NUMA::numa()), _length_of_node(NULL), |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
337 |
_num_nodes(_numa->num_active_nodes()) { |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
338 |
assert(UseNUMA, "Invariant"); |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
339 |
|
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
340 |
_length_of_node = NEW_C_HEAP_ARRAY(uint, _num_nodes, mtGC); |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
341 |
} |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
342 |
|
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
343 |
FreeRegionList::NodeInfo::~NodeInfo() { |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
344 |
FREE_C_HEAP_ARRAY(uint, _length_of_node); |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
345 |
} |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
346 |
|
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
347 |
void FreeRegionList::NodeInfo::clear() { |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
348 |
for (uint i = 0; i < _num_nodes; ++i) { |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
349 |
_length_of_node[i] = 0; |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
350 |
} |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
351 |
} |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
352 |
|
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
353 |
void FreeRegionList::NodeInfo::add(NodeInfo* info) { |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
354 |
for (uint i = 0; i < _num_nodes; ++i) { |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
355 |
_length_of_node[i] += info->_length_of_node[i]; |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
356 |
} |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
357 |
} |
6530de931b8e
8220312: Implementation: NUMA-Aware Memory Allocation for G1, Logging (3/3)
sangheki
parents:
53116
diff
changeset
|
358 |