author | zgu |
Thu, 01 Mar 2018 16:35:36 -0500 | |
changeset 49193 | c3ec048aad63 |
parent 49033 | 3acc342c0738 |
child 49349 | 7194eb9e8f19 |
permissions | -rw-r--r-- |
25946 | 1 |
/* |
49033
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
2 |
* Copyright (c) 2013, 2018, Oracle and/or its affiliates. All rights reserved. |
25946 | 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 |
#include "precompiled.hpp" |
|
25 |
||
47553
5d20359dd938
8186770: NMT: Report metadata information in NMT summary
zgu
parents:
47216
diff
changeset
|
26 |
#include "memory/metaspace.hpp" |
40655
9f644073d3a0
8157907: Incorrect inclusion of atomic.hpp instead of atomic.inline.hpp
dholmes
parents:
38935
diff
changeset
|
27 |
#include "runtime/atomic.hpp" |
38935 | 28 |
#include "runtime/os.hpp" |
25946 | 29 |
#include "runtime/threadCritical.hpp" |
38935 | 30 |
#include "services/memTracker.hpp" |
25946 | 31 |
#include "services/virtualMemoryTracker.hpp" |
32 |
||
33 |
size_t VirtualMemorySummary::_snapshot[CALC_OBJ_SIZE_IN_TYPE(VirtualMemorySnapshot, size_t)]; |
|
34 |
||
35 |
void VirtualMemorySummary::initialize() { |
|
36 |
assert(sizeof(_snapshot) >= sizeof(VirtualMemorySnapshot), "Sanity Check"); |
|
37 |
// Use placement operator new to initialize static data area. |
|
38 |
::new ((void*)_snapshot) VirtualMemorySnapshot(); |
|
39 |
} |
|
40 |
||
49193 | 41 |
void VirtualMemorySummary::snapshot(VirtualMemorySnapshot* s) { |
42 |
// Snapshot current thread stacks |
|
43 |
VirtualMemoryTracker::snapshot_thread_stacks(); |
|
44 |
as_snapshot()->copy_to(s); |
|
45 |
} |
|
46 |
||
26136
254c226e4402
8054368: nsk/jdi/VirtualMachine/exit/exit002 crash with detail tracking on (NMT2)
zgu
parents:
25946
diff
changeset
|
47 |
SortedLinkedList<ReservedMemoryRegion, compare_reserved_region_base>* VirtualMemoryTracker::_reserved_regions; |
25946 | 48 |
|
49 |
int compare_committed_region(const CommittedMemoryRegion& r1, const CommittedMemoryRegion& r2) { |
|
50 |
return r1.compare(r2); |
|
51 |
} |
|
52 |
||
53 |
int compare_reserved_region_base(const ReservedMemoryRegion& r1, const ReservedMemoryRegion& r2) { |
|
54 |
return r1.compare(r2); |
|
55 |
} |
|
56 |
||
49033
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
57 |
static bool is_mergeable_with(CommittedMemoryRegion* rgn, address addr, size_t size, const NativeCallStack& stack) { |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
58 |
return rgn->adjacent_to(addr, size) && rgn->call_stack()->equals(stack); |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
59 |
} |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
60 |
|
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
61 |
static bool is_same_as(CommittedMemoryRegion* rgn, address addr, size_t size, const NativeCallStack& stack) { |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
62 |
// It would have made sense to use rgn->equals(...), but equals returns true for overlapping regions. |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
63 |
return rgn->same_region(addr, size) && rgn->call_stack()->equals(stack); |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
64 |
} |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
65 |
|
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
66 |
static LinkedListNode<CommittedMemoryRegion>* find_preceding_node_from(LinkedListNode<CommittedMemoryRegion>* from, address addr) { |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
67 |
LinkedListNode<CommittedMemoryRegion>* preceding = NULL; |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
68 |
|
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
69 |
for (LinkedListNode<CommittedMemoryRegion>* node = from; node != NULL; node = node->next()) { |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
70 |
CommittedMemoryRegion* rgn = node->data(); |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
71 |
|
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
72 |
// We searched past the region start. |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
73 |
if (rgn->end() > addr) { |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
74 |
break; |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
75 |
} |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
76 |
|
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
77 |
preceding = node; |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
78 |
} |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
79 |
|
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
80 |
return preceding; |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
81 |
} |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
82 |
|
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
83 |
static bool try_merge_with(LinkedListNode<CommittedMemoryRegion>* node, address addr, size_t size, const NativeCallStack& stack) { |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
84 |
if (node != NULL) { |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
85 |
CommittedMemoryRegion* rgn = node->data(); |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
86 |
|
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
87 |
if (is_mergeable_with(rgn, addr, size, stack)) { |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
88 |
rgn->expand_region(addr, size); |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
89 |
return true; |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
90 |
} |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
91 |
} |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
92 |
|
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
93 |
return false; |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
94 |
} |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
95 |
|
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
96 |
static bool try_merge_with(LinkedListNode<CommittedMemoryRegion>* node, LinkedListNode<CommittedMemoryRegion>* other) { |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
97 |
if (other == NULL) { |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
98 |
return false; |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
99 |
} |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
100 |
|
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
101 |
CommittedMemoryRegion* rgn = other->data(); |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
102 |
return try_merge_with(node, rgn->base(), rgn->size(), *rgn->call_stack()); |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
103 |
} |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
104 |
|
25946 | 105 |
bool ReservedMemoryRegion::add_committed_region(address addr, size_t size, const NativeCallStack& stack) { |
106 |
assert(addr != NULL, "Invalid address"); |
|
107 |
assert(size > 0, "Invalid size"); |
|
108 |
assert(contain_region(addr, size), "Not contain this region"); |
|
109 |
||
49033
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
110 |
// Find the region that fully precedes the [addr, addr + size) region. |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
111 |
LinkedListNode<CommittedMemoryRegion>* prev = find_preceding_node_from(_committed_regions.head(), addr); |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
112 |
LinkedListNode<CommittedMemoryRegion>* next = (prev != NULL ? prev->next() : _committed_regions.head()); |
25946 | 113 |
|
49033
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
114 |
if (next != NULL) { |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
115 |
// Ignore request if region already exists. |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
116 |
if (is_same_as(next->data(), addr, size, stack)) { |
25946 | 117 |
return true; |
118 |
} |
|
119 |
||
49033
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
120 |
// The new region is after prev, and either overlaps with the |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
121 |
// next region (and maybe more regions), or overlaps with no region. |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
122 |
if (next->data()->overlap_region(addr, size)) { |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
123 |
// Remove _all_ overlapping regions, and parts of regions, |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
124 |
// in preparation for the addition of this new region. |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
125 |
remove_uncommitted_region(addr, size); |
38935 | 126 |
|
49033
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
127 |
// The remove could have split a region into two and created a |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
128 |
// new prev region. Need to reset the prev and next pointers. |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
129 |
prev = find_preceding_node_from((prev != NULL ? prev : _committed_regions.head()), addr); |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
130 |
next = (prev != NULL ? prev->next() : _committed_regions.head()); |
25946 | 131 |
} |
38935 | 132 |
} |
133 |
||
49033
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
134 |
// At this point the previous overlapping regions have been |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
135 |
// cleared, and the full region is guaranteed to be inserted. |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
136 |
VirtualMemorySummary::record_committed_memory(size, flag()); |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
137 |
|
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
138 |
// Try to merge with prev and possibly next. |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
139 |
if (try_merge_with(prev, addr, size, stack)) { |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
140 |
if (try_merge_with(prev, next)) { |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
141 |
// prev was expanded to contain the new region |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
142 |
// and next, need to remove next from the list |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
143 |
_committed_regions.remove_after(prev); |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
144 |
} |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
145 |
|
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
146 |
return true; |
48818
ec4a84ba2aaf
8196372: [BACKOUT] NMT: add_committed_regions doesn't merge succeeding regions
jwilhelm
parents:
48815
diff
changeset
|
147 |
} |
25946 | 148 |
|
49033
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
149 |
// Didn't merge with prev, try with next. |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
150 |
if (try_merge_with(next, addr, size, stack)) { |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
151 |
return true; |
25946 | 152 |
} |
49033
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
153 |
|
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
154 |
// Couldn't merge with any regions - create a new region. |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
155 |
return add_committed_region(CommittedMemoryRegion(addr, size, stack)); |
25946 | 156 |
} |
157 |
||
158 |
bool ReservedMemoryRegion::remove_uncommitted_region(LinkedListNode<CommittedMemoryRegion>* node, |
|
159 |
address addr, size_t size) { |
|
160 |
assert(addr != NULL, "Invalid address"); |
|
161 |
assert(size > 0, "Invalid size"); |
|
162 |
||
163 |
CommittedMemoryRegion* rgn = node->data(); |
|
164 |
assert(rgn->contain_region(addr, size), "Has to be contained"); |
|
165 |
assert(!rgn->same_region(addr, size), "Can not be the same region"); |
|
166 |
||
167 |
if (rgn->base() == addr || |
|
168 |
rgn->end() == addr + size) { |
|
169 |
rgn->exclude_region(addr, size); |
|
170 |
return true; |
|
171 |
} else { |
|
172 |
// split this region |
|
173 |
address top =rgn->end(); |
|
174 |
// use this region for lower part |
|
175 |
size_t exclude_size = rgn->end() - addr; |
|
176 |
rgn->exclude_region(addr, exclude_size); |
|
177 |
||
178 |
// higher part |
|
179 |
address high_base = addr + size; |
|
180 |
size_t high_size = top - high_base; |
|
181 |
||
182 |
CommittedMemoryRegion high_rgn(high_base, high_size, *rgn->call_stack()); |
|
183 |
LinkedListNode<CommittedMemoryRegion>* high_node = _committed_regions.add(high_rgn); |
|
184 |
assert(high_node == NULL || node->next() == high_node, "Should be right after"); |
|
185 |
return (high_node != NULL); |
|
186 |
} |
|
187 |
||
188 |
return false; |
|
189 |
} |
|
190 |
||
191 |
bool ReservedMemoryRegion::remove_uncommitted_region(address addr, size_t sz) { |
|
192 |
assert(addr != NULL, "Invalid address"); |
|
193 |
assert(sz > 0, "Invalid size"); |
|
194 |
||
49033
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
195 |
CommittedMemoryRegion del_rgn(addr, sz, *call_stack()); |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
196 |
address end = addr + sz; |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
197 |
|
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
198 |
LinkedListNode<CommittedMemoryRegion>* head = _committed_regions.head(); |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
199 |
LinkedListNode<CommittedMemoryRegion>* prev = NULL; |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
200 |
CommittedMemoryRegion* crgn; |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
201 |
|
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
202 |
while (head != NULL) { |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
203 |
crgn = head->data(); |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
204 |
|
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
205 |
if (crgn->same_region(addr, sz)) { |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
206 |
VirtualMemorySummary::record_uncommitted_memory(crgn->size(), flag()); |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
207 |
_committed_regions.remove_after(prev); |
25946 | 208 |
return true; |
49033
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
209 |
} |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
210 |
|
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
211 |
// del_rgn contains crgn |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
212 |
if (del_rgn.contain_region(crgn->base(), crgn->size())) { |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
213 |
VirtualMemorySummary::record_uncommitted_memory(crgn->size(), flag()); |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
214 |
head = head->next(); |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
215 |
_committed_regions.remove_after(prev); |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
216 |
continue; // don't update head or prev |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
217 |
} |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
218 |
|
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
219 |
// Found addr in the current crgn. There are 2 subcases: |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
220 |
if (crgn->contain_address(addr)) { |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
221 |
|
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
222 |
// (1) Found addr+size in current crgn as well. (del_rgn is contained in crgn) |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
223 |
if (crgn->contain_address(end - 1)) { |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
224 |
VirtualMemorySummary::record_uncommitted_memory(sz, flag()); |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
225 |
return remove_uncommitted_region(head, addr, sz); // done! |
25946 | 226 |
} else { |
49033
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
227 |
// (2) Did not find del_rgn's end in crgn. |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
228 |
size_t size = crgn->end() - del_rgn.base(); |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
229 |
crgn->exclude_region(addr, size); |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
230 |
VirtualMemorySummary::record_uncommitted_memory(size, flag()); |
38935 | 231 |
} |
232 |
||
49033
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
233 |
} else if (crgn->contain_address(end - 1)) { |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
234 |
// Found del_rgn's end, but not its base addr. |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
235 |
size_t size = del_rgn.end() - crgn->base(); |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
236 |
crgn->exclude_region(crgn->base(), size); |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
237 |
VirtualMemorySummary::record_uncommitted_memory(size, flag()); |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
238 |
return true; // should be done if the list is sorted properly! |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
239 |
} |
38935 | 240 |
|
49033
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
241 |
prev = head; |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
242 |
head = head->next(); |
25946 | 243 |
} |
244 |
||
245 |
return true; |
|
246 |
} |
|
247 |
||
248 |
void ReservedMemoryRegion::move_committed_regions(address addr, ReservedMemoryRegion& rgn) { |
|
249 |
assert(addr != NULL, "Invalid address"); |
|
250 |
||
251 |
// split committed regions |
|
252 |
LinkedListNode<CommittedMemoryRegion>* head = |
|
253 |
_committed_regions.head(); |
|
254 |
LinkedListNode<CommittedMemoryRegion>* prev = NULL; |
|
255 |
||
256 |
while (head != NULL) { |
|
257 |
if (head->data()->base() >= addr) { |
|
258 |
break; |
|
259 |
} |
|
260 |
prev = head; |
|
261 |
head = head->next(); |
|
262 |
} |
|
263 |
||
264 |
if (head != NULL) { |
|
265 |
if (prev != NULL) { |
|
266 |
prev->set_next(head->next()); |
|
267 |
} else { |
|
268 |
_committed_regions.set_head(NULL); |
|
269 |
} |
|
270 |
} |
|
271 |
||
272 |
rgn._committed_regions.set_head(head); |
|
273 |
} |
|
274 |
||
275 |
size_t ReservedMemoryRegion::committed_size() const { |
|
49033
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
276 |
size_t committed = 0; |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
277 |
LinkedListNode<CommittedMemoryRegion>* head = |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
278 |
_committed_regions.head(); |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
279 |
while (head != NULL) { |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
280 |
committed += head->data()->size(); |
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
281 |
head = head->next(); |
25946 | 282 |
} |
49033
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
283 |
return committed; |
25946 | 284 |
} |
285 |
||
286 |
void ReservedMemoryRegion::set_flag(MEMFLAGS f) { |
|
287 |
assert((flag() == mtNone || flag() == f), "Overwrite memory type"); |
|
288 |
if (flag() != f) { |
|
289 |
VirtualMemorySummary::move_reserved_memory(flag(), f, size()); |
|
290 |
VirtualMemorySummary::move_committed_memory(flag(), f, committed_size()); |
|
291 |
_flag = f; |
|
292 |
} |
|
293 |
} |
|
294 |
||
49193 | 295 |
address ReservedMemoryRegion::thread_stack_uncommitted_bottom() const { |
296 |
assert(flag() == mtThreadStack, "Only for thread stack"); |
|
297 |
LinkedListNode<CommittedMemoryRegion>* head = _committed_regions.head(); |
|
298 |
address bottom = base(); |
|
299 |
address top = base() + size(); |
|
300 |
while (head != NULL) { |
|
301 |
address committed_top = head->data()->base() + head->data()->size(); |
|
302 |
if (committed_top < top) { |
|
303 |
// committed stack guard pages, skip them |
|
304 |
bottom = head->data()->base() + head->data()->size(); |
|
305 |
head = head->next(); |
|
306 |
} else { |
|
307 |
assert(top == committed_top, "Sanity"); |
|
308 |
break; |
|
309 |
} |
|
310 |
} |
|
311 |
||
312 |
return bottom; |
|
313 |
} |
|
314 |
||
25946 | 315 |
bool VirtualMemoryTracker::initialize(NMT_TrackingLevel level) { |
316 |
if (level >= NMT_summary) { |
|
317 |
VirtualMemorySummary::initialize(); |
|
318 |
} |
|
319 |
return true; |
|
320 |
} |
|
321 |
||
26136
254c226e4402
8054368: nsk/jdi/VirtualMachine/exit/exit002 crash with detail tracking on (NMT2)
zgu
parents:
25946
diff
changeset
|
322 |
bool VirtualMemoryTracker::late_initialize(NMT_TrackingLevel level) { |
254c226e4402
8054368: nsk/jdi/VirtualMachine/exit/exit002 crash with detail tracking on (NMT2)
zgu
parents:
25946
diff
changeset
|
323 |
if (level >= NMT_summary) { |
254c226e4402
8054368: nsk/jdi/VirtualMachine/exit/exit002 crash with detail tracking on (NMT2)
zgu
parents:
25946
diff
changeset
|
324 |
_reserved_regions = new (std::nothrow, ResourceObj::C_HEAP, mtNMT) |
254c226e4402
8054368: nsk/jdi/VirtualMachine/exit/exit002 crash with detail tracking on (NMT2)
zgu
parents:
25946
diff
changeset
|
325 |
SortedLinkedList<ReservedMemoryRegion, compare_reserved_region_base>(); |
254c226e4402
8054368: nsk/jdi/VirtualMachine/exit/exit002 crash with detail tracking on (NMT2)
zgu
parents:
25946
diff
changeset
|
326 |
return (_reserved_regions != NULL); |
254c226e4402
8054368: nsk/jdi/VirtualMachine/exit/exit002 crash with detail tracking on (NMT2)
zgu
parents:
25946
diff
changeset
|
327 |
} |
254c226e4402
8054368: nsk/jdi/VirtualMachine/exit/exit002 crash with detail tracking on (NMT2)
zgu
parents:
25946
diff
changeset
|
328 |
return true; |
254c226e4402
8054368: nsk/jdi/VirtualMachine/exit/exit002 crash with detail tracking on (NMT2)
zgu
parents:
25946
diff
changeset
|
329 |
} |
254c226e4402
8054368: nsk/jdi/VirtualMachine/exit/exit002 crash with detail tracking on (NMT2)
zgu
parents:
25946
diff
changeset
|
330 |
|
25946 | 331 |
bool VirtualMemoryTracker::add_reserved_region(address base_addr, size_t size, |
49033
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
332 |
const NativeCallStack& stack, MEMFLAGS flag) { |
25946 | 333 |
assert(base_addr != NULL, "Invalid address"); |
334 |
assert(size > 0, "Invalid size"); |
|
26136
254c226e4402
8054368: nsk/jdi/VirtualMachine/exit/exit002 crash with detail tracking on (NMT2)
zgu
parents:
25946
diff
changeset
|
335 |
assert(_reserved_regions != NULL, "Sanity check"); |
25946 | 336 |
ReservedMemoryRegion rgn(base_addr, size, stack, flag); |
26136
254c226e4402
8054368: nsk/jdi/VirtualMachine/exit/exit002 crash with detail tracking on (NMT2)
zgu
parents:
25946
diff
changeset
|
337 |
ReservedMemoryRegion* reserved_rgn = _reserved_regions->find(rgn); |
49033
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
338 |
|
25946 | 339 |
if (reserved_rgn == NULL) { |
340 |
VirtualMemorySummary::record_reserved_memory(size, flag); |
|
49033
3acc342c0738
8196405: [REDO] NMT: add_committed_regions doesn't merge succeeding regions
stefank
parents:
48818
diff
changeset
|
341 |
return _reserved_regions->add(rgn) != NULL; |
25946 | 342 |
} else { |
343 |
if (reserved_rgn->same_region(base_addr, size)) { |
|
344 |
reserved_rgn->set_call_stack(stack); |
|
345 |
reserved_rgn->set_flag(flag); |
|
346 |
return true; |
|
347 |
} else if (reserved_rgn->adjacent_to(base_addr, size)) { |
|
348 |
VirtualMemorySummary::record_reserved_memory(size, flag); |
|
349 |
reserved_rgn->expand_region(base_addr, size); |
|
350 |
reserved_rgn->set_call_stack(stack); |
|
351 |
return true; |
|
352 |
} else { |
|
353 |
// Overlapped reservation. |
|
354 |
// It can happen when the regions are thread stacks, as JNI |
|
355 |
// thread does not detach from VM before exits, and leads to |
|
356 |
// leak JavaThread object |
|
357 |
if (reserved_rgn->flag() == mtThreadStack) { |
|
358 |
guarantee(!CheckJNICalls, "Attached JNI thread exited without being detached"); |
|
359 |
// Overwrite with new region |
|
360 |
||
361 |
// Release old region |
|
362 |
VirtualMemorySummary::record_uncommitted_memory(reserved_rgn->committed_size(), reserved_rgn->flag()); |
|
363 |
VirtualMemorySummary::record_released_memory(reserved_rgn->size(), reserved_rgn->flag()); |
|
364 |
||
365 |
// Add new region |
|
366 |
VirtualMemorySummary::record_reserved_memory(rgn.size(), flag); |
|
367 |
||
368 |
*reserved_rgn = rgn; |
|
369 |
return true; |
|
370 |
} |
|
26146
ce3202564442
8055061: assert at share/vm/services/virtualMemoryTracker.cpp:332 Error: ShouldNotReachHere() when running NMT tests
zgu
parents:
26136
diff
changeset
|
371 |
|
ce3202564442
8055061: assert at share/vm/services/virtualMemoryTracker.cpp:332 Error: ShouldNotReachHere() when running NMT tests
zgu
parents:
26136
diff
changeset
|
372 |
// CDS mapping region. |
ce3202564442
8055061: assert at share/vm/services/virtualMemoryTracker.cpp:332 Error: ShouldNotReachHere() when running NMT tests
zgu
parents:
26136
diff
changeset
|
373 |
// CDS reserves the whole region for mapping CDS archive, then maps each section into the region. |
ce3202564442
8055061: assert at share/vm/services/virtualMemoryTracker.cpp:332 Error: ShouldNotReachHere() when running NMT tests
zgu
parents:
26136
diff
changeset
|
374 |
// NMT reports CDS as a whole. |
ce3202564442
8055061: assert at share/vm/services/virtualMemoryTracker.cpp:332 Error: ShouldNotReachHere() when running NMT tests
zgu
parents:
26136
diff
changeset
|
375 |
if (reserved_rgn->flag() == mtClassShared) { |
ce3202564442
8055061: assert at share/vm/services/virtualMemoryTracker.cpp:332 Error: ShouldNotReachHere() when running NMT tests
zgu
parents:
26136
diff
changeset
|
376 |
assert(reserved_rgn->contain_region(base_addr, size), "Reserved CDS region should contain this mapping region"); |
ce3202564442
8055061: assert at share/vm/services/virtualMemoryTracker.cpp:332 Error: ShouldNotReachHere() when running NMT tests
zgu
parents:
26136
diff
changeset
|
377 |
return true; |
ce3202564442
8055061: assert at share/vm/services/virtualMemoryTracker.cpp:332 Error: ShouldNotReachHere() when running NMT tests
zgu
parents:
26136
diff
changeset
|
378 |
} |
ce3202564442
8055061: assert at share/vm/services/virtualMemoryTracker.cpp:332 Error: ShouldNotReachHere() when running NMT tests
zgu
parents:
26136
diff
changeset
|
379 |
|
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
27162
diff
changeset
|
380 |
// Mapped CDS string region. |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
27162
diff
changeset
|
381 |
// The string region(s) is part of the java heap. |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
27162
diff
changeset
|
382 |
if (reserved_rgn->flag() == mtJavaHeap) { |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
27162
diff
changeset
|
383 |
assert(reserved_rgn->contain_region(base_addr, size), "Reserved heap region should contain this mapping region"); |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
27162
diff
changeset
|
384 |
return true; |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
27162
diff
changeset
|
385 |
} |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
27162
diff
changeset
|
386 |
|
26146
ce3202564442
8055061: assert at share/vm/services/virtualMemoryTracker.cpp:332 Error: ShouldNotReachHere() when running NMT tests
zgu
parents:
26136
diff
changeset
|
387 |
ShouldNotReachHere(); |
ce3202564442
8055061: assert at share/vm/services/virtualMemoryTracker.cpp:332 Error: ShouldNotReachHere() when running NMT tests
zgu
parents:
26136
diff
changeset
|
388 |
return false; |
25946 | 389 |
} |
390 |
} |
|
391 |
} |
|
392 |
||
393 |
void VirtualMemoryTracker::set_reserved_region_type(address addr, MEMFLAGS flag) { |
|
394 |
assert(addr != NULL, "Invalid address"); |
|
26136
254c226e4402
8054368: nsk/jdi/VirtualMachine/exit/exit002 crash with detail tracking on (NMT2)
zgu
parents:
25946
diff
changeset
|
395 |
assert(_reserved_regions != NULL, "Sanity check"); |
25946 | 396 |
|
397 |
ReservedMemoryRegion rgn(addr, 1); |
|
26136
254c226e4402
8054368: nsk/jdi/VirtualMachine/exit/exit002 crash with detail tracking on (NMT2)
zgu
parents:
25946
diff
changeset
|
398 |
ReservedMemoryRegion* reserved_rgn = _reserved_regions->find(rgn); |
25946 | 399 |
if (reserved_rgn != NULL) { |
400 |
assert(reserved_rgn->contain_address(addr), "Containment"); |
|
401 |
if (reserved_rgn->flag() != flag) { |
|
402 |
assert(reserved_rgn->flag() == mtNone, "Overwrite memory type"); |
|
403 |
reserved_rgn->set_flag(flag); |
|
404 |
} |
|
405 |
} |
|
406 |
} |
|
407 |
||
408 |
bool VirtualMemoryTracker::add_committed_region(address addr, size_t size, |
|
409 |
const NativeCallStack& stack) { |
|
410 |
assert(addr != NULL, "Invalid address"); |
|
411 |
assert(size > 0, "Invalid size"); |
|
26136
254c226e4402
8054368: nsk/jdi/VirtualMachine/exit/exit002 crash with detail tracking on (NMT2)
zgu
parents:
25946
diff
changeset
|
412 |
assert(_reserved_regions != NULL, "Sanity check"); |
254c226e4402
8054368: nsk/jdi/VirtualMachine/exit/exit002 crash with detail tracking on (NMT2)
zgu
parents:
25946
diff
changeset
|
413 |
|
25946 | 414 |
ReservedMemoryRegion rgn(addr, size); |
26136
254c226e4402
8054368: nsk/jdi/VirtualMachine/exit/exit002 crash with detail tracking on (NMT2)
zgu
parents:
25946
diff
changeset
|
415 |
ReservedMemoryRegion* reserved_rgn = _reserved_regions->find(rgn); |
25946 | 416 |
|
417 |
assert(reserved_rgn != NULL, "No reserved region"); |
|
418 |
assert(reserved_rgn->contain_region(addr, size), "Not completely contained"); |
|
38935 | 419 |
bool result = reserved_rgn->add_committed_region(addr, size, stack); |
420 |
return result; |
|
25946 | 421 |
} |
422 |
||
423 |
bool VirtualMemoryTracker::remove_uncommitted_region(address addr, size_t size) { |
|
424 |
assert(addr != NULL, "Invalid address"); |
|
425 |
assert(size > 0, "Invalid size"); |
|
26136
254c226e4402
8054368: nsk/jdi/VirtualMachine/exit/exit002 crash with detail tracking on (NMT2)
zgu
parents:
25946
diff
changeset
|
426 |
assert(_reserved_regions != NULL, "Sanity check"); |
254c226e4402
8054368: nsk/jdi/VirtualMachine/exit/exit002 crash with detail tracking on (NMT2)
zgu
parents:
25946
diff
changeset
|
427 |
|
25946 | 428 |
ReservedMemoryRegion rgn(addr, size); |
26136
254c226e4402
8054368: nsk/jdi/VirtualMachine/exit/exit002 crash with detail tracking on (NMT2)
zgu
parents:
25946
diff
changeset
|
429 |
ReservedMemoryRegion* reserved_rgn = _reserved_regions->find(rgn); |
25946 | 430 |
assert(reserved_rgn != NULL, "No reserved region"); |
431 |
assert(reserved_rgn->contain_region(addr, size), "Not completely contained"); |
|
38935 | 432 |
bool result = reserved_rgn->remove_uncommitted_region(addr, size); |
433 |
return result; |
|
25946 | 434 |
} |
435 |
||
436 |
bool VirtualMemoryTracker::remove_released_region(address addr, size_t size) { |
|
437 |
assert(addr != NULL, "Invalid address"); |
|
438 |
assert(size > 0, "Invalid size"); |
|
26136
254c226e4402
8054368: nsk/jdi/VirtualMachine/exit/exit002 crash with detail tracking on (NMT2)
zgu
parents:
25946
diff
changeset
|
439 |
assert(_reserved_regions != NULL, "Sanity check"); |
25946 | 440 |
|
441 |
ReservedMemoryRegion rgn(addr, size); |
|
26136
254c226e4402
8054368: nsk/jdi/VirtualMachine/exit/exit002 crash with detail tracking on (NMT2)
zgu
parents:
25946
diff
changeset
|
442 |
ReservedMemoryRegion* reserved_rgn = _reserved_regions->find(rgn); |
25946 | 443 |
|
444 |
assert(reserved_rgn != NULL, "No reserved region"); |
|
445 |
||
446 |
// uncommit regions within the released region |
|
447 |
if (!reserved_rgn->remove_uncommitted_region(addr, size)) { |
|
448 |
return false; |
|
449 |
} |
|
450 |
||
35483
d9cf65a7fd2d
8146523: VirtualMemoryTracker::remove_released_region double count unmapped CDS shared memory
jiangli
parents:
33127
diff
changeset
|
451 |
if (reserved_rgn->flag() == mtClassShared && |
d9cf65a7fd2d
8146523: VirtualMemoryTracker::remove_released_region double count unmapped CDS shared memory
jiangli
parents:
33127
diff
changeset
|
452 |
reserved_rgn->contain_region(addr, size) && |
d9cf65a7fd2d
8146523: VirtualMemoryTracker::remove_released_region double count unmapped CDS shared memory
jiangli
parents:
33127
diff
changeset
|
453 |
!reserved_rgn->same_region(addr, size)) { |
d9cf65a7fd2d
8146523: VirtualMemoryTracker::remove_released_region double count unmapped CDS shared memory
jiangli
parents:
33127
diff
changeset
|
454 |
// This is an unmapped CDS region, which is part of the reserved shared |
d9cf65a7fd2d
8146523: VirtualMemoryTracker::remove_released_region double count unmapped CDS shared memory
jiangli
parents:
33127
diff
changeset
|
455 |
// memory region. |
d9cf65a7fd2d
8146523: VirtualMemoryTracker::remove_released_region double count unmapped CDS shared memory
jiangli
parents:
33127
diff
changeset
|
456 |
// See special handling in VirtualMemoryTracker::add_reserved_region also. |
d9cf65a7fd2d
8146523: VirtualMemoryTracker::remove_released_region double count unmapped CDS shared memory
jiangli
parents:
33127
diff
changeset
|
457 |
return true; |
d9cf65a7fd2d
8146523: VirtualMemoryTracker::remove_released_region double count unmapped CDS shared memory
jiangli
parents:
33127
diff
changeset
|
458 |
} |
25946 | 459 |
|
460 |
VirtualMemorySummary::record_released_memory(size, reserved_rgn->flag()); |
|
461 |
||
462 |
if (reserved_rgn->same_region(addr, size)) { |
|
26136
254c226e4402
8054368: nsk/jdi/VirtualMachine/exit/exit002 crash with detail tracking on (NMT2)
zgu
parents:
25946
diff
changeset
|
463 |
return _reserved_regions->remove(rgn); |
25946 | 464 |
} else { |
465 |
assert(reserved_rgn->contain_region(addr, size), "Not completely contained"); |
|
466 |
if (reserved_rgn->base() == addr || |
|
467 |
reserved_rgn->end() == addr + size) { |
|
468 |
reserved_rgn->exclude_region(addr, size); |
|
469 |
return true; |
|
470 |
} else { |
|
471 |
address top = reserved_rgn->end(); |
|
472 |
address high_base = addr + size; |
|
473 |
ReservedMemoryRegion high_rgn(high_base, top - high_base, |
|
474 |
*reserved_rgn->call_stack(), reserved_rgn->flag()); |
|
475 |
||
476 |
// use original region for lower region |
|
477 |
reserved_rgn->exclude_region(addr, top - addr); |
|
26136
254c226e4402
8054368: nsk/jdi/VirtualMachine/exit/exit002 crash with detail tracking on (NMT2)
zgu
parents:
25946
diff
changeset
|
478 |
LinkedListNode<ReservedMemoryRegion>* new_rgn = _reserved_regions->add(high_rgn); |
25946 | 479 |
if (new_rgn == NULL) { |
480 |
return false; |
|
481 |
} else { |
|
482 |
reserved_rgn->move_committed_regions(addr, *new_rgn->data()); |
|
483 |
return true; |
|
484 |
} |
|
485 |
} |
|
486 |
} |
|
487 |
} |
|
488 |
||
49193 | 489 |
// Walk all known thread stacks, snapshot their committed ranges. |
490 |
class SnapshotThreadStackWalker : public VirtualMemoryWalker { |
|
491 |
public: |
|
492 |
SnapshotThreadStackWalker() {} |
|
493 |
||
494 |
bool do_allocation_site(const ReservedMemoryRegion* rgn) { |
|
495 |
if (rgn->flag() == mtThreadStack) { |
|
496 |
address stack_bottom = rgn->thread_stack_uncommitted_bottom(); |
|
497 |
size_t stack_size = rgn->base() + rgn->size() - stack_bottom; |
|
498 |
size_t committed_size = os::committed_stack_size(stack_bottom, stack_size); |
|
499 |
if (committed_size > 0) { |
|
500 |
ReservedMemoryRegion* region = const_cast<ReservedMemoryRegion*>(rgn); |
|
501 |
NativeCallStack ncs; // empty stack |
|
502 |
||
503 |
// Stack grows downward |
|
504 |
region->add_committed_region(rgn->base() + rgn->size() - committed_size, committed_size, ncs); |
|
505 |
} |
|
506 |
} |
|
507 |
return true; |
|
508 |
} |
|
509 |
}; |
|
510 |
||
511 |
void VirtualMemoryTracker::snapshot_thread_stacks() { |
|
512 |
SnapshotThreadStackWalker walker; |
|
513 |
walk_virtual_memory(&walker); |
|
514 |
} |
|
25946 | 515 |
|
516 |
bool VirtualMemoryTracker::walk_virtual_memory(VirtualMemoryWalker* walker) { |
|
26136
254c226e4402
8054368: nsk/jdi/VirtualMachine/exit/exit002 crash with detail tracking on (NMT2)
zgu
parents:
25946
diff
changeset
|
517 |
assert(_reserved_regions != NULL, "Sanity check"); |
25946 | 518 |
ThreadCritical tc; |
27162
0a4a7276949b
8059100: SIGSEGV VirtualMemoryTracker::remove_released_region
coleenp
parents:
26149
diff
changeset
|
519 |
// Check that the _reserved_regions haven't been deleted. |
0a4a7276949b
8059100: SIGSEGV VirtualMemoryTracker::remove_released_region
coleenp
parents:
26149
diff
changeset
|
520 |
if (_reserved_regions != NULL) { |
0a4a7276949b
8059100: SIGSEGV VirtualMemoryTracker::remove_released_region
coleenp
parents:
26149
diff
changeset
|
521 |
LinkedListNode<ReservedMemoryRegion>* head = _reserved_regions->head(); |
0a4a7276949b
8059100: SIGSEGV VirtualMemoryTracker::remove_released_region
coleenp
parents:
26149
diff
changeset
|
522 |
while (head != NULL) { |
0a4a7276949b
8059100: SIGSEGV VirtualMemoryTracker::remove_released_region
coleenp
parents:
26149
diff
changeset
|
523 |
const ReservedMemoryRegion* rgn = head->peek(); |
0a4a7276949b
8059100: SIGSEGV VirtualMemoryTracker::remove_released_region
coleenp
parents:
26149
diff
changeset
|
524 |
if (!walker->do_allocation_site(rgn)) { |
0a4a7276949b
8059100: SIGSEGV VirtualMemoryTracker::remove_released_region
coleenp
parents:
26149
diff
changeset
|
525 |
return false; |
0a4a7276949b
8059100: SIGSEGV VirtualMemoryTracker::remove_released_region
coleenp
parents:
26149
diff
changeset
|
526 |
} |
0a4a7276949b
8059100: SIGSEGV VirtualMemoryTracker::remove_released_region
coleenp
parents:
26149
diff
changeset
|
527 |
head = head->next(); |
25946 | 528 |
} |
27162
0a4a7276949b
8059100: SIGSEGV VirtualMemoryTracker::remove_released_region
coleenp
parents:
26149
diff
changeset
|
529 |
} |
25946 | 530 |
return true; |
531 |
} |
|
532 |
||
533 |
// Transition virtual memory tracking level. |
|
534 |
bool VirtualMemoryTracker::transition(NMT_TrackingLevel from, NMT_TrackingLevel to) { |
|
27162
0a4a7276949b
8059100: SIGSEGV VirtualMemoryTracker::remove_released_region
coleenp
parents:
26149
diff
changeset
|
535 |
assert (from != NMT_minimal, "cannot convert from the lowest tracking level to anything"); |
0a4a7276949b
8059100: SIGSEGV VirtualMemoryTracker::remove_released_region
coleenp
parents:
26149
diff
changeset
|
536 |
if (to == NMT_minimal) { |
25946 | 537 |
assert(from == NMT_summary || from == NMT_detail, "Just check"); |
538 |
// Clean up virtual memory tracking data structures. |
|
539 |
ThreadCritical tc; |
|
27162
0a4a7276949b
8059100: SIGSEGV VirtualMemoryTracker::remove_released_region
coleenp
parents:
26149
diff
changeset
|
540 |
// Check for potential race with other thread calling transition |
26136
254c226e4402
8054368: nsk/jdi/VirtualMachine/exit/exit002 crash with detail tracking on (NMT2)
zgu
parents:
25946
diff
changeset
|
541 |
if (_reserved_regions != NULL) { |
254c226e4402
8054368: nsk/jdi/VirtualMachine/exit/exit002 crash with detail tracking on (NMT2)
zgu
parents:
25946
diff
changeset
|
542 |
delete _reserved_regions; |
254c226e4402
8054368: nsk/jdi/VirtualMachine/exit/exit002 crash with detail tracking on (NMT2)
zgu
parents:
25946
diff
changeset
|
543 |
_reserved_regions = NULL; |
254c226e4402
8054368: nsk/jdi/VirtualMachine/exit/exit002 crash with detail tracking on (NMT2)
zgu
parents:
25946
diff
changeset
|
544 |
} |
25946 | 545 |
} |
546 |
||
547 |
return true; |
|
548 |
} |
|
47553
5d20359dd938
8186770: NMT: Report metadata information in NMT summary
zgu
parents:
47216
diff
changeset
|
549 |
|
5d20359dd938
8186770: NMT: Report metadata information in NMT summary
zgu
parents:
47216
diff
changeset
|
550 |
// Metaspace Support |
5d20359dd938
8186770: NMT: Report metadata information in NMT summary
zgu
parents:
47216
diff
changeset
|
551 |
MetaspaceSnapshot::MetaspaceSnapshot() { |
5d20359dd938
8186770: NMT: Report metadata information in NMT summary
zgu
parents:
47216
diff
changeset
|
552 |
for (int index = (int)Metaspace::ClassType; index < (int)Metaspace::MetadataTypeCount; index ++) { |
5d20359dd938
8186770: NMT: Report metadata information in NMT summary
zgu
parents:
47216
diff
changeset
|
553 |
Metaspace::MetadataType type = (Metaspace::MetadataType)index; |
5d20359dd938
8186770: NMT: Report metadata information in NMT summary
zgu
parents:
47216
diff
changeset
|
554 |
assert_valid_metadata_type(type); |
5d20359dd938
8186770: NMT: Report metadata information in NMT summary
zgu
parents:
47216
diff
changeset
|
555 |
_reserved_in_bytes[type] = 0; |
5d20359dd938
8186770: NMT: Report metadata information in NMT summary
zgu
parents:
47216
diff
changeset
|
556 |
_committed_in_bytes[type] = 0; |
5d20359dd938
8186770: NMT: Report metadata information in NMT summary
zgu
parents:
47216
diff
changeset
|
557 |
_used_in_bytes[type] = 0; |
5d20359dd938
8186770: NMT: Report metadata information in NMT summary
zgu
parents:
47216
diff
changeset
|
558 |
_free_in_bytes[type] = 0; |
5d20359dd938
8186770: NMT: Report metadata information in NMT summary
zgu
parents:
47216
diff
changeset
|
559 |
} |
5d20359dd938
8186770: NMT: Report metadata information in NMT summary
zgu
parents:
47216
diff
changeset
|
560 |
} |
5d20359dd938
8186770: NMT: Report metadata information in NMT summary
zgu
parents:
47216
diff
changeset
|
561 |
|
5d20359dd938
8186770: NMT: Report metadata information in NMT summary
zgu
parents:
47216
diff
changeset
|
562 |
void MetaspaceSnapshot::snapshot(Metaspace::MetadataType type, MetaspaceSnapshot& mss) { |
5d20359dd938
8186770: NMT: Report metadata information in NMT summary
zgu
parents:
47216
diff
changeset
|
563 |
assert_valid_metadata_type(type); |
5d20359dd938
8186770: NMT: Report metadata information in NMT summary
zgu
parents:
47216
diff
changeset
|
564 |
|
5d20359dd938
8186770: NMT: Report metadata information in NMT summary
zgu
parents:
47216
diff
changeset
|
565 |
mss._reserved_in_bytes[type] = MetaspaceAux::reserved_bytes(type); |
5d20359dd938
8186770: NMT: Report metadata information in NMT summary
zgu
parents:
47216
diff
changeset
|
566 |
mss._committed_in_bytes[type] = MetaspaceAux::committed_bytes(type); |
5d20359dd938
8186770: NMT: Report metadata information in NMT summary
zgu
parents:
47216
diff
changeset
|
567 |
mss._used_in_bytes[type] = MetaspaceAux::used_bytes(type); |
5d20359dd938
8186770: NMT: Report metadata information in NMT summary
zgu
parents:
47216
diff
changeset
|
568 |
|
5d20359dd938
8186770: NMT: Report metadata information in NMT summary
zgu
parents:
47216
diff
changeset
|
569 |
size_t free_in_bytes = (MetaspaceAux::capacity_bytes(type) - MetaspaceAux::used_bytes(type)) |
5d20359dd938
8186770: NMT: Report metadata information in NMT summary
zgu
parents:
47216
diff
changeset
|
570 |
+ MetaspaceAux::free_chunks_total_bytes(type) |
5d20359dd938
8186770: NMT: Report metadata information in NMT summary
zgu
parents:
47216
diff
changeset
|
571 |
+ MetaspaceAux::free_bytes(type); |
5d20359dd938
8186770: NMT: Report metadata information in NMT summary
zgu
parents:
47216
diff
changeset
|
572 |
mss._free_in_bytes[type] = free_in_bytes; |
5d20359dd938
8186770: NMT: Report metadata information in NMT summary
zgu
parents:
47216
diff
changeset
|
573 |
} |
5d20359dd938
8186770: NMT: Report metadata information in NMT summary
zgu
parents:
47216
diff
changeset
|
574 |
|
5d20359dd938
8186770: NMT: Report metadata information in NMT summary
zgu
parents:
47216
diff
changeset
|
575 |
void MetaspaceSnapshot::snapshot(MetaspaceSnapshot& mss) { |
5d20359dd938
8186770: NMT: Report metadata information in NMT summary
zgu
parents:
47216
diff
changeset
|
576 |
snapshot(Metaspace::ClassType, mss); |
5d20359dd938
8186770: NMT: Report metadata information in NMT summary
zgu
parents:
47216
diff
changeset
|
577 |
if (Metaspace::using_class_space()) { |
5d20359dd938
8186770: NMT: Report metadata information in NMT summary
zgu
parents:
47216
diff
changeset
|
578 |
snapshot(Metaspace::NonClassType, mss); |
5d20359dd938
8186770: NMT: Report metadata information in NMT summary
zgu
parents:
47216
diff
changeset
|
579 |
} |
5d20359dd938
8186770: NMT: Report metadata information in NMT summary
zgu
parents:
47216
diff
changeset
|
580 |
} |