Mercurial > hg > truffle
annotate src/share/vm/services/memSnapshot.cpp @ 7378:88506cfc3bab
Canonicalize ((a - a % b) / b) into (a / b).
author | Thomas Wuerthinger <thomas.wuerthinger@oracle.com> |
---|---|
date | Tue, 15 Jan 2013 17:53:31 +0100 |
parents | 49cbd3e25ba9 |
children | ecd24264898b |
rev | line source |
---|---|
6197 | 1 /* |
2 * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. | |
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | |
4 * | |
5 * This code is free software; you can redistribute it and/or modify it | |
6 * under the terms of the GNU General Public License version 2 only, as | |
7 * published by the Free Software Foundation. | |
8 * | |
9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
12 * version 2 for more details (a copy is included in the LICENSE file that | |
13 * accompanied this code). | |
14 * | |
15 * You should have received a copy of the GNU General Public License version | |
16 * 2 along with this work; if not, write to the Free Software Foundation, | |
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
18 * | |
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | |
20 * or visit www.oracle.com if you need additional information or have any | |
21 * questions. | |
22 * | |
23 */ | |
24 | |
25 #include "precompiled.hpp" | |
26 #include "runtime/mutexLocker.hpp" | |
27 #include "utilities/decoder.hpp" | |
28 #include "services/memBaseline.hpp" | |
29 #include "services/memPtr.hpp" | |
30 #include "services/memPtrArray.hpp" | |
31 #include "services/memSnapshot.hpp" | |
32 #include "services/memTracker.hpp" | |
33 | |
6937
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
34 #ifdef ASSERT |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
35 |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
36 void decode_pointer_record(MemPointerRecord* rec) { |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
37 tty->print("Pointer: [" PTR_FORMAT " - " PTR_FORMAT "] size = %d bytes", rec->addr(), |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
38 rec->addr() + rec->size(), (int)rec->size()); |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
39 tty->print(" type = %s", MemBaseline::type2name(FLAGS_TO_MEMORY_TYPE(rec->flags()))); |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
40 if (rec->is_vm_pointer()) { |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
41 if (rec->is_allocation_record()) { |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
42 tty->print_cr(" (reserve)"); |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
43 } else if (rec->is_commit_record()) { |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
44 tty->print_cr(" (commit)"); |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
45 } else if (rec->is_uncommit_record()) { |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
46 tty->print_cr(" (uncommit)"); |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
47 } else if (rec->is_deallocation_record()) { |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
48 tty->print_cr(" (release)"); |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
49 } else { |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
50 tty->print_cr(" (tag)"); |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
51 } |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
52 } else { |
6979
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
53 if (rec->is_arena_memory_record()) { |
6937
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
54 tty->print_cr(" (arena size)"); |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
55 } else if (rec->is_allocation_record()) { |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
56 tty->print_cr(" (malloc)"); |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
57 } else { |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
58 tty->print_cr(" (free)"); |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
59 } |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
60 } |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
61 if (MemTracker::track_callsite()) { |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
62 char buf[1024]; |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
63 address pc = ((MemPointerRecordEx*)rec)->pc(); |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
64 if (pc != NULL && os::dll_address_to_function_name(pc, buf, sizeof(buf), NULL)) { |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
65 tty->print_cr("\tfrom %s", buf); |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
66 } else { |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
67 tty->print_cr("\tcould not decode pc = " PTR_FORMAT "", pc); |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
68 } |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
69 } |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
70 } |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
71 |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
72 void decode_vm_region_record(VMMemRegion* rec) { |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
73 tty->print("VM Region [" PTR_FORMAT " - " PTR_FORMAT "]", rec->addr(), |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
74 rec->addr() + rec->size()); |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
75 tty->print(" type = %s", MemBaseline::type2name(FLAGS_TO_MEMORY_TYPE(rec->flags()))); |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
76 if (rec->is_allocation_record()) { |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
77 tty->print_cr(" (reserved)"); |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
78 } else if (rec->is_commit_record()) { |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
79 tty->print_cr(" (committed)"); |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
80 } else { |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
81 ShouldNotReachHere(); |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
82 } |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
83 if (MemTracker::track_callsite()) { |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
84 char buf[1024]; |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
85 address pc = ((VMMemRegionEx*)rec)->pc(); |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
86 if (pc != NULL && os::dll_address_to_function_name(pc, buf, sizeof(buf), NULL)) { |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
87 tty->print_cr("\tfrom %s", buf); |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
88 } else { |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
89 tty->print_cr("\tcould not decode pc = " PTR_FORMAT "", pc); |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
90 } |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
91 |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
92 } |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
93 } |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
94 |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
95 #endif |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
96 |
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
97 |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
98 bool VMMemPointerIterator::insert_record(MemPointerRecord* rec) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
99 VMMemRegionEx new_rec; |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
100 assert(rec->is_allocation_record() || rec->is_commit_record(), |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
101 "Sanity check"); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
102 if (MemTracker::track_callsite()) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
103 new_rec.init((MemPointerRecordEx*)rec); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
104 } else { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
105 new_rec.init(rec); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
106 } |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
107 return insert(&new_rec); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
108 } |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
109 |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
110 bool VMMemPointerIterator::insert_record_after(MemPointerRecord* rec) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
111 VMMemRegionEx new_rec; |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
112 assert(rec->is_allocation_record() || rec->is_commit_record(), |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
113 "Sanity check"); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
114 if (MemTracker::track_callsite()) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
115 new_rec.init((MemPointerRecordEx*)rec); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
116 } else { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
117 new_rec.init(rec); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
118 } |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
119 return insert_after(&new_rec); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
120 } |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
121 |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
122 // we don't consolidate reserved regions, since they may be categorized |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
123 // in different types. |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
124 bool VMMemPointerIterator::add_reserved_region(MemPointerRecord* rec) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
125 assert(rec->is_allocation_record(), "Sanity check"); |
6977
ed8b1e39ff4f
8002273: NMT to report JNI memory leaks when -Xcheck:jni is on
zgu
parents:
6937
diff
changeset
|
126 VMMemRegion* reserved_region = (VMMemRegion*)current(); |
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
127 |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
128 // we don't have anything yet |
6977
ed8b1e39ff4f
8002273: NMT to report JNI memory leaks when -Xcheck:jni is on
zgu
parents:
6937
diff
changeset
|
129 if (reserved_region == NULL) { |
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
130 return insert_record(rec); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
131 } |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
132 |
6977
ed8b1e39ff4f
8002273: NMT to report JNI memory leaks when -Xcheck:jni is on
zgu
parents:
6937
diff
changeset
|
133 assert(reserved_region->is_reserved_region(), "Sanity check"); |
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
134 // duplicated records |
6977
ed8b1e39ff4f
8002273: NMT to report JNI memory leaks when -Xcheck:jni is on
zgu
parents:
6937
diff
changeset
|
135 if (reserved_region->is_same_region(rec)) { |
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
136 return true; |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
137 } |
6977
ed8b1e39ff4f
8002273: NMT to report JNI memory leaks when -Xcheck:jni is on
zgu
parents:
6937
diff
changeset
|
138 // Overlapping stack regions indicate that a JNI thread failed to |
ed8b1e39ff4f
8002273: NMT to report JNI memory leaks when -Xcheck:jni is on
zgu
parents:
6937
diff
changeset
|
139 // detach from the VM before exiting. This leaks the JavaThread object. |
ed8b1e39ff4f
8002273: NMT to report JNI memory leaks when -Xcheck:jni is on
zgu
parents:
6937
diff
changeset
|
140 if (CheckJNICalls) { |
ed8b1e39ff4f
8002273: NMT to report JNI memory leaks when -Xcheck:jni is on
zgu
parents:
6937
diff
changeset
|
141 guarantee(FLAGS_TO_MEMORY_TYPE(reserved_region->flags()) != mtThreadStack || |
ed8b1e39ff4f
8002273: NMT to report JNI memory leaks when -Xcheck:jni is on
zgu
parents:
6937
diff
changeset
|
142 !reserved_region->overlaps_region(rec), |
ed8b1e39ff4f
8002273: NMT to report JNI memory leaks when -Xcheck:jni is on
zgu
parents:
6937
diff
changeset
|
143 "Attached JNI thread exited without being detached"); |
ed8b1e39ff4f
8002273: NMT to report JNI memory leaks when -Xcheck:jni is on
zgu
parents:
6937
diff
changeset
|
144 } |
ed8b1e39ff4f
8002273: NMT to report JNI memory leaks when -Xcheck:jni is on
zgu
parents:
6937
diff
changeset
|
145 // otherwise, we should not have overlapping reserved regions |
ed8b1e39ff4f
8002273: NMT to report JNI memory leaks when -Xcheck:jni is on
zgu
parents:
6937
diff
changeset
|
146 assert(FLAGS_TO_MEMORY_TYPE(reserved_region->flags()) == mtThreadStack || |
ed8b1e39ff4f
8002273: NMT to report JNI memory leaks when -Xcheck:jni is on
zgu
parents:
6937
diff
changeset
|
147 reserved_region->base() > rec->addr(), "Just check: locate()"); |
ed8b1e39ff4f
8002273: NMT to report JNI memory leaks when -Xcheck:jni is on
zgu
parents:
6937
diff
changeset
|
148 assert(FLAGS_TO_MEMORY_TYPE(reserved_region->flags()) == mtThreadStack || |
ed8b1e39ff4f
8002273: NMT to report JNI memory leaks when -Xcheck:jni is on
zgu
parents:
6937
diff
changeset
|
149 !reserved_region->overlaps_region(rec), "overlapping reserved regions"); |
ed8b1e39ff4f
8002273: NMT to report JNI memory leaks when -Xcheck:jni is on
zgu
parents:
6937
diff
changeset
|
150 |
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
151 return insert_record(rec); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
152 } |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
153 |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
154 // we do consolidate committed regions |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
155 bool VMMemPointerIterator::add_committed_region(MemPointerRecord* rec) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
156 assert(rec->is_commit_record(), "Sanity check"); |
6937
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
157 VMMemRegion* reserved_rgn = (VMMemRegion*)current(); |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
158 assert(reserved_rgn->is_reserved_region() && reserved_rgn->contains_region(rec), |
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
159 "Sanity check"); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
160 |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
161 // thread's native stack is always marked as "committed", ignore |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
162 // the "commit" operation for creating stack guard pages |
6937
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
163 if (FLAGS_TO_MEMORY_TYPE(reserved_rgn->flags()) == mtThreadStack && |
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
164 FLAGS_TO_MEMORY_TYPE(rec->flags()) != mtThreadStack) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
165 return true; |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
166 } |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
167 |
6937
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
168 // if the reserved region has any committed regions |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
169 VMMemRegion* committed_rgn = (VMMemRegion*)next(); |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
170 while (committed_rgn != NULL && committed_rgn->is_committed_region()) { |
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
171 // duplicated commit records |
6937
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
172 if(committed_rgn->contains_region(rec)) { |
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
173 return true; |
6937
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
174 } else if (committed_rgn->overlaps_region(rec)) { |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
175 // overlaps front part |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
176 if (rec->addr() < committed_rgn->addr()) { |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
177 committed_rgn->expand_region(rec->addr(), |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
178 committed_rgn->addr() - rec->addr()); |
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
179 } else { |
6937
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
180 // overlaps tail part |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
181 address committed_rgn_end = committed_rgn->addr() + |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
182 committed_rgn->size(); |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
183 assert(committed_rgn_end < rec->addr() + rec->size(), |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
184 "overlap tail part"); |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
185 committed_rgn->expand_region(committed_rgn_end, |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
186 (rec->addr() + rec->size()) - committed_rgn_end); |
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
187 } |
6937
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
188 } else if (committed_rgn->base() + committed_rgn->size() == rec->addr()) { |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
189 // adjunct each other |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
190 committed_rgn->expand_region(rec->addr(), rec->size()); |
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
191 VMMemRegion* next_reg = (VMMemRegion*)next(); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
192 // see if we can consolidate next committed region |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
193 if (next_reg != NULL && next_reg->is_committed_region() && |
6937
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
194 next_reg->base() == committed_rgn->base() + committed_rgn->size()) { |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
195 committed_rgn->expand_region(next_reg->base(), next_reg->size()); |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
196 // delete merged region |
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
197 remove(); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
198 } |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
199 return true; |
6937
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
200 } else if (committed_rgn->base() > rec->addr()) { |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
201 // found the location, insert this committed region |
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
202 return insert_record(rec); |
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
203 } |
6937
69ad7823b1ca
8001591: NMT: assertion failed: assert(rec->addr() + rec->size() <= cur->base()) failed: Can not overlap in memSnapshot.cpp
zgu
parents:
6882
diff
changeset
|
204 committed_rgn = (VMMemRegion*)next(); |
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
205 } |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
206 return insert_record(rec); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
207 } |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
208 |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
209 bool VMMemPointerIterator::remove_uncommitted_region(MemPointerRecord* rec) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
210 assert(rec->is_uncommit_record(), "sanity check"); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
211 VMMemRegion* cur; |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
212 cur = (VMMemRegion*)current(); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
213 assert(cur->is_reserved_region() && cur->contains_region(rec), |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
214 "Sanity check"); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
215 // thread's native stack is always marked as "committed", ignore |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
216 // the "commit" operation for creating stack guard pages |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
217 if (FLAGS_TO_MEMORY_TYPE(cur->flags()) == mtThreadStack && |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
218 FLAGS_TO_MEMORY_TYPE(rec->flags()) != mtThreadStack) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
219 return true; |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
220 } |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
221 |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
222 cur = (VMMemRegion*)next(); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
223 while (cur != NULL && cur->is_committed_region()) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
224 // region already uncommitted, must be due to duplicated record |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
225 if (cur->addr() >= rec->addr() + rec->size()) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
226 break; |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
227 } else if (cur->contains_region(rec)) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
228 // uncommit whole region |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
229 if (cur->is_same_region(rec)) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
230 remove(); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
231 break; |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
232 } else if (rec->addr() == cur->addr() || |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
233 rec->addr() + rec->size() == cur->addr() + cur->size()) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
234 // uncommitted from either end of current memory region. |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
235 cur->exclude_region(rec->addr(), rec->size()); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
236 break; |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
237 } else { // split the committed region and release the middle |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
238 address high_addr = cur->addr() + cur->size(); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
239 size_t sz = high_addr - rec->addr(); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
240 cur->exclude_region(rec->addr(), sz); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
241 sz = high_addr - (rec->addr() + rec->size()); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
242 if (MemTracker::track_callsite()) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
243 MemPointerRecordEx tmp(rec->addr() + rec->size(), cur->flags(), sz, |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
244 ((VMMemRegionEx*)cur)->pc()); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
245 return insert_record_after(&tmp); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
246 } else { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
247 MemPointerRecord tmp(rec->addr() + rec->size(), cur->flags(), sz); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
248 return insert_record_after(&tmp); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
249 } |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
250 } |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
251 } |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
252 cur = (VMMemRegion*)next(); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
253 } |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
254 |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
255 // we may not find committed record due to duplicated records |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
256 return true; |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
257 } |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
258 |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
259 bool VMMemPointerIterator::remove_released_region(MemPointerRecord* rec) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
260 assert(rec->is_deallocation_record(), "Sanity check"); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
261 VMMemRegion* cur = (VMMemRegion*)current(); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
262 assert(cur->is_reserved_region() && cur->contains_region(rec), |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
263 "Sanity check"); |
7166
49cbd3e25ba9
8003487: NMT: incorrect assertion in VMMemPointerIterator::remove_released_region method (memSnapshot.cpp)
zgu
parents:
6981
diff
changeset
|
264 if (rec->is_same_region(cur)) { |
49cbd3e25ba9
8003487: NMT: incorrect assertion in VMMemPointerIterator::remove_released_region method (memSnapshot.cpp)
zgu
parents:
6981
diff
changeset
|
265 // release whole reserved region |
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
266 #ifdef ASSERT |
7166
49cbd3e25ba9
8003487: NMT: incorrect assertion in VMMemPointerIterator::remove_released_region method (memSnapshot.cpp)
zgu
parents:
6981
diff
changeset
|
267 VMMemRegion* next_region = (VMMemRegion*)peek_next(); |
49cbd3e25ba9
8003487: NMT: incorrect assertion in VMMemPointerIterator::remove_released_region method (memSnapshot.cpp)
zgu
parents:
6981
diff
changeset
|
268 // should not have any committed memory in this reserved region |
49cbd3e25ba9
8003487: NMT: incorrect assertion in VMMemPointerIterator::remove_released_region method (memSnapshot.cpp)
zgu
parents:
6981
diff
changeset
|
269 assert(next_region == NULL || !next_region->is_committed_region(), "Sanity check"); |
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
270 #endif |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
271 remove(); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
272 } else if (rec->addr() == cur->addr() || |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
273 rec->addr() + rec->size() == cur->addr() + cur->size()) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
274 // released region is at either end of this region |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
275 cur->exclude_region(rec->addr(), rec->size()); |
7166
49cbd3e25ba9
8003487: NMT: incorrect assertion in VMMemPointerIterator::remove_released_region method (memSnapshot.cpp)
zgu
parents:
6981
diff
changeset
|
276 assert(check_reserved_region(), "Integrity check"); |
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
277 } else { // split the reserved region and release the middle |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
278 address high_addr = cur->addr() + cur->size(); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
279 size_t sz = high_addr - rec->addr(); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
280 cur->exclude_region(rec->addr(), sz); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
281 sz = high_addr - rec->addr() - rec->size(); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
282 if (MemTracker::track_callsite()) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
283 MemPointerRecordEx tmp(rec->addr() + rec->size(), cur->flags(), sz, |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
284 ((VMMemRegionEx*)cur)->pc()); |
7166
49cbd3e25ba9
8003487: NMT: incorrect assertion in VMMemPointerIterator::remove_released_region method (memSnapshot.cpp)
zgu
parents:
6981
diff
changeset
|
285 bool ret = insert_reserved_region(&tmp); |
49cbd3e25ba9
8003487: NMT: incorrect assertion in VMMemPointerIterator::remove_released_region method (memSnapshot.cpp)
zgu
parents:
6981
diff
changeset
|
286 assert(!ret || check_reserved_region(), "Integrity check"); |
49cbd3e25ba9
8003487: NMT: incorrect assertion in VMMemPointerIterator::remove_released_region method (memSnapshot.cpp)
zgu
parents:
6981
diff
changeset
|
287 return ret; |
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
288 } else { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
289 MemPointerRecord tmp(rec->addr() + rec->size(), cur->flags(), sz); |
7166
49cbd3e25ba9
8003487: NMT: incorrect assertion in VMMemPointerIterator::remove_released_region method (memSnapshot.cpp)
zgu
parents:
6981
diff
changeset
|
290 bool ret = insert_reserved_region(&tmp); |
49cbd3e25ba9
8003487: NMT: incorrect assertion in VMMemPointerIterator::remove_released_region method (memSnapshot.cpp)
zgu
parents:
6981
diff
changeset
|
291 assert(!ret || check_reserved_region(), "Integrity check"); |
49cbd3e25ba9
8003487: NMT: incorrect assertion in VMMemPointerIterator::remove_released_region method (memSnapshot.cpp)
zgu
parents:
6981
diff
changeset
|
292 return ret; |
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
293 } |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
294 } |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
295 return true; |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
296 } |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
297 |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
298 bool VMMemPointerIterator::insert_reserved_region(MemPointerRecord* rec) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
299 // skip all 'commit' records associated with previous reserved region |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
300 VMMemRegion* p = (VMMemRegion*)next(); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
301 while (p != NULL && p->is_committed_region() && |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
302 p->base() + p->size() < rec->addr()) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
303 p = (VMMemRegion*)next(); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
304 } |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
305 return insert_record(rec); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
306 } |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
307 |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
308 bool VMMemPointerIterator::split_reserved_region(VMMemRegion* rgn, address new_rgn_addr, size_t new_rgn_size) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
309 assert(rgn->contains_region(new_rgn_addr, new_rgn_size), "Not fully contained"); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
310 address pc = (MemTracker::track_callsite() ? ((VMMemRegionEx*)rgn)->pc() : NULL); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
311 if (rgn->base() == new_rgn_addr) { // new region is at the beginning of the region |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
312 size_t sz = rgn->size() - new_rgn_size; |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
313 // the original region becomes 'new' region |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
314 rgn->exclude_region(new_rgn_addr + new_rgn_size, sz); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
315 // remaining becomes next region |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
316 MemPointerRecordEx next_rgn(new_rgn_addr + new_rgn_size, rgn->flags(), sz, pc); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
317 return insert_reserved_region(&next_rgn); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
318 } else if (rgn->base() + rgn->size() == new_rgn_addr + new_rgn_size) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
319 rgn->exclude_region(new_rgn_addr, new_rgn_size); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
320 MemPointerRecordEx next_rgn(new_rgn_addr, rgn->flags(), new_rgn_size, pc); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
321 return insert_reserved_region(&next_rgn); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
322 } else { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
323 // the orginal region will be split into three |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
324 address rgn_high_addr = rgn->base() + rgn->size(); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
325 // first region |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
326 rgn->exclude_region(new_rgn_addr, (rgn_high_addr - new_rgn_addr)); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
327 // the second region is the new region |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
328 MemPointerRecordEx new_rgn(new_rgn_addr, rgn->flags(), new_rgn_size, pc); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
329 if (!insert_reserved_region(&new_rgn)) return false; |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
330 // the remaining region |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
331 MemPointerRecordEx rem_rgn(new_rgn_addr + new_rgn_size, rgn->flags(), |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
332 rgn_high_addr - (new_rgn_addr + new_rgn_size), pc); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
333 return insert_reserved_region(&rem_rgn); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
334 } |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
335 } |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
336 |
6741
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
337 static int sort_in_seq_order(const void* p1, const void* p2) { |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
338 assert(p1 != NULL && p2 != NULL, "Sanity check"); |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
339 const MemPointerRecord* mp1 = (MemPointerRecord*)p1; |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
340 const MemPointerRecord* mp2 = (MemPointerRecord*)p2; |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
341 return (mp1->seq() - mp2->seq()); |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
342 } |
6197 | 343 |
6741
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
344 bool StagingArea::init() { |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
345 if (MemTracker::track_callsite()) { |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
346 _malloc_data = new (std::nothrow)MemPointerArrayImpl<SeqMemPointerRecordEx>(); |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
347 _vm_data = new (std::nothrow)MemPointerArrayImpl<SeqMemPointerRecordEx>(); |
6197 | 348 } else { |
6741
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
349 _malloc_data = new (std::nothrow)MemPointerArrayImpl<SeqMemPointerRecord>(); |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
350 _vm_data = new (std::nothrow)MemPointerArrayImpl<SeqMemPointerRecord>(); |
6197 | 351 } |
352 | |
6741
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
353 if (_malloc_data != NULL && _vm_data != NULL && |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
354 !_malloc_data->out_of_memory() && |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
355 !_vm_data->out_of_memory()) { |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
356 return true; |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
357 } else { |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
358 if (_malloc_data != NULL) delete _malloc_data; |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
359 if (_vm_data != NULL) delete _vm_data; |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
360 _malloc_data = NULL; |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
361 _vm_data = NULL; |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
362 return false; |
6197 | 363 } |
364 } | |
365 | |
366 | |
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
367 VMRecordIterator StagingArea::virtual_memory_record_walker() { |
6741
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
368 MemPointerArray* arr = vm_data(); |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
369 // sort into seq number order |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
370 arr->sort((FN_SORT)sort_in_seq_order); |
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
371 return VMRecordIterator(arr); |
6741
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
372 } |
6197 | 373 |
374 | |
375 MemSnapshot::MemSnapshot() { | |
376 if (MemTracker::track_callsite()) { | |
377 _alloc_ptrs = new (std::nothrow) MemPointerArrayImpl<MemPointerRecordEx>(); | |
378 _vm_ptrs = new (std::nothrow)MemPointerArrayImpl<VMMemRegionEx>(64, true); | |
379 } else { | |
380 _alloc_ptrs = new (std::nothrow) MemPointerArrayImpl<MemPointerRecord>(); | |
381 _vm_ptrs = new (std::nothrow)MemPointerArrayImpl<VMMemRegion>(64, true); | |
382 } | |
383 | |
6741
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
384 _staging_area.init(); |
6232
f1f45dddb0bd
7181986: NMT ON: Assertion failure when running jdi ExpiredRequestDeletionTest
zgu
parents:
6197
diff
changeset
|
385 _lock = new (std::nothrow) Mutex(Monitor::max_nonleaf - 1, "memSnapshotLock"); |
6197 | 386 NOT_PRODUCT(_untracked_count = 0;) |
387 } | |
388 | |
389 MemSnapshot::~MemSnapshot() { | |
390 assert(MemTracker::shutdown_in_progress(), "native memory tracking still on"); | |
391 { | |
392 MutexLockerEx locker(_lock); | |
393 if (_alloc_ptrs != NULL) { | |
394 delete _alloc_ptrs; | |
395 _alloc_ptrs = NULL; | |
396 } | |
397 | |
398 if (_vm_ptrs != NULL) { | |
399 delete _vm_ptrs; | |
400 _vm_ptrs = NULL; | |
401 } | |
402 } | |
403 | |
404 if (_lock != NULL) { | |
405 delete _lock; | |
406 _lock = NULL; | |
407 } | |
408 } | |
409 | |
6979
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
410 |
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
411 void MemSnapshot::copy_seq_pointer(MemPointerRecord* dest, const MemPointerRecord* src) { |
6197 | 412 assert(dest != NULL && src != NULL, "Just check"); |
413 assert(dest->addr() == src->addr(), "Just check"); | |
6979
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
414 assert(dest->seq() > 0 && src->seq() > 0, "not sequenced"); |
6197 | 415 |
6979
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
416 if (MemTracker::track_callsite()) { |
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
417 *(SeqMemPointerRecordEx*)dest = *(SeqMemPointerRecordEx*)src; |
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
418 } else { |
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
419 *(SeqMemPointerRecord*)dest = *(SeqMemPointerRecord*)src; |
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
420 } |
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
421 } |
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
422 |
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
423 void MemSnapshot::assign_pointer(MemPointerRecord*dest, const MemPointerRecord* src) { |
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
424 assert(src != NULL && dest != NULL, "Just check"); |
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
425 assert(dest->seq() == 0 && src->seq() >0, "cast away sequence"); |
6197 | 426 |
427 if (MemTracker::track_callsite()) { | |
428 *(MemPointerRecordEx*)dest = *(MemPointerRecordEx*)src; | |
429 } else { | |
6979
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
430 *(MemPointerRecord*)dest = *(MemPointerRecord*)src; |
6197 | 431 } |
432 } | |
433 | |
6979
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
434 // merge a recorder to the staging area |
6197 | 435 bool MemSnapshot::merge(MemRecorder* rec) { |
436 assert(rec != NULL && !rec->out_of_memory(), "Just check"); | |
437 | |
438 SequencedRecordIterator itr(rec->pointer_itr()); | |
439 | |
440 MutexLockerEx lock(_lock, true); | |
6741
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
441 MemPointerIterator malloc_staging_itr(_staging_area.malloc_data()); |
6979
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
442 MemPointerRecord* incoming_rec = (MemPointerRecord*) itr.current(); |
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
443 MemPointerRecord* matched_rec; |
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
444 |
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
445 while (incoming_rec != NULL) { |
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
446 if (incoming_rec->is_vm_pointer()) { |
6741
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
447 // we don't do anything with virtual memory records during merge |
6979
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
448 if (!_staging_area.vm_data()->append(incoming_rec)) { |
6197 | 449 return false; |
450 } | |
6741
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
451 } else { |
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
452 // locate matched record and/or also position the iterator to proper |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
453 // location for this incoming record. |
6979
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
454 matched_rec = (MemPointerRecord*)malloc_staging_itr.locate(incoming_rec->addr()); |
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
455 // we have not seen this memory block in this generation, |
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
456 // so just add to staging area |
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
457 if (matched_rec == NULL) { |
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
458 if (!malloc_staging_itr.insert(incoming_rec)) { |
6741
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
459 return false; |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
460 } |
6979
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
461 } else if (incoming_rec->addr() == matched_rec->addr()) { |
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
462 // whoever has higher sequence number wins |
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
463 if (incoming_rec->seq() > matched_rec->seq()) { |
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
464 copy_seq_pointer(matched_rec, incoming_rec); |
6197 | 465 } |
6979
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
466 } else if (incoming_rec->addr() < matched_rec->addr()) { |
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
467 if (!malloc_staging_itr.insert(incoming_rec)) { |
6197 | 468 return false; |
469 } | |
470 } else { | |
6979
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
471 ShouldNotReachHere(); |
6197 | 472 } |
473 } | |
6979
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
474 incoming_rec = (MemPointerRecord*)itr.next(); |
6197 | 475 } |
476 NOT_PRODUCT(void check_staging_data();) | |
477 return true; | |
478 } | |
479 | |
480 | |
481 // promote data to next generation | |
6741
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
482 bool MemSnapshot::promote() { |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
483 assert(_alloc_ptrs != NULL && _vm_ptrs != NULL, "Just check"); |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
484 assert(_staging_area.malloc_data() != NULL && _staging_area.vm_data() != NULL, |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
485 "Just check"); |
6197 | 486 MutexLockerEx lock(_lock, true); |
6741
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
487 |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
488 MallocRecordIterator malloc_itr = _staging_area.malloc_record_walker(); |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
489 bool promoted = false; |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
490 if (promote_malloc_records(&malloc_itr)) { |
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
491 VMRecordIterator vm_itr = _staging_area.virtual_memory_record_walker(); |
6741
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
492 if (promote_virtual_memory_records(&vm_itr)) { |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
493 promoted = true; |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
494 } |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
495 } |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
496 |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
497 NOT_PRODUCT(check_malloc_pointers();) |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
498 _staging_area.clear(); |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
499 return promoted; |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
500 } |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
501 |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
502 bool MemSnapshot::promote_malloc_records(MemPointerArrayIterator* itr) { |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
503 MemPointerIterator malloc_snapshot_itr(_alloc_ptrs); |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
504 MemPointerRecord* new_rec = (MemPointerRecord*)itr->current(); |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
505 MemPointerRecord* matched_rec; |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
506 while (new_rec != NULL) { |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
507 matched_rec = (MemPointerRecord*)malloc_snapshot_itr.locate(new_rec->addr()); |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
508 // found matched memory block |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
509 if (matched_rec != NULL && new_rec->addr() == matched_rec->addr()) { |
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
510 // snapshot already contains 'live' records |
6979
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
511 assert(matched_rec->is_allocation_record() || matched_rec->is_arena_memory_record(), |
6741
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
512 "Sanity check"); |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
513 // update block states |
6979
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
514 if (new_rec->is_allocation_record()) { |
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
515 assign_pointer(matched_rec, new_rec); |
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
516 } else if (new_rec->is_arena_memory_record()) { |
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
517 if (new_rec->size() == 0) { |
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
518 // remove size record once size drops to 0 |
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
519 malloc_snapshot_itr.remove(); |
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
520 } else { |
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
521 assign_pointer(matched_rec, new_rec); |
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
522 } |
6741
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
523 } else { |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
524 // a deallocation record |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
525 assert(new_rec->is_deallocation_record(), "Sanity check"); |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
526 // an arena record can be followed by a size record, we need to remove both |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
527 if (matched_rec->is_arena_record()) { |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
528 MemPointerRecord* next = (MemPointerRecord*)malloc_snapshot_itr.peek_next(); |
6979
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
529 if (next->is_arena_memory_record() && next->is_memory_record_of_arena(matched_rec)) { |
6741
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
530 malloc_snapshot_itr.remove(); |
6197 | 531 } |
6741
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
532 } |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
533 // the memory is deallocated, remove related record(s) |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
534 malloc_snapshot_itr.remove(); |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
535 } |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
536 } else { |
6979
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
537 // don't insert size 0 record |
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
538 if (new_rec->is_arena_memory_record() && new_rec->size() == 0) { |
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
539 new_rec = NULL; |
6741
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
540 } |
6979
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
541 |
6741
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
542 if (new_rec != NULL) { |
6979
fb3190e77d3c
8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180
zgu
parents:
6937
diff
changeset
|
543 if (new_rec->is_allocation_record() || new_rec->is_arena_memory_record()) { |
6741
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
544 if (matched_rec != NULL && new_rec->addr() > matched_rec->addr()) { |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
545 if (!malloc_snapshot_itr.insert_after(new_rec)) { |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
546 return false; |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
547 } |
6197 | 548 } else { |
6741
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
549 if (!malloc_snapshot_itr.insert(new_rec)) { |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
550 return false; |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
551 } |
6197 | 552 } |
6741
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
553 } |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
554 #ifndef PRODUCT |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
555 else if (!has_allocation_record(new_rec->addr())) { |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
556 // NMT can not track some startup memory, which is allocated before NMT is on |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
557 _untracked_count ++; |
6197 | 558 } |
6741
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
559 #endif |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
560 } |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
561 } |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
562 new_rec = (MemPointerRecord*)itr->next(); |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
563 } |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
564 return true; |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
565 } |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
566 |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
567 bool MemSnapshot::promote_virtual_memory_records(MemPointerArrayIterator* itr) { |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
568 VMMemPointerIterator vm_snapshot_itr(_vm_ptrs); |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
569 MemPointerRecord* new_rec = (MemPointerRecord*)itr->current(); |
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
570 VMMemRegion* reserved_rec; |
6741
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
571 while (new_rec != NULL) { |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
572 assert(new_rec->is_vm_pointer(), "Sanity check"); |
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
573 |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
574 // locate a reserved region that contains the specified address, or |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
575 // the nearest reserved region has base address just above the specified |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
576 // address |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
577 reserved_rec = (VMMemRegion*)vm_snapshot_itr.locate(new_rec->addr()); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
578 if (reserved_rec != NULL && reserved_rec->contains_region(new_rec)) { |
6741
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
579 // snapshot can only have 'live' records |
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
580 assert(reserved_rec->is_reserved_region(), "Sanity check"); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
581 if (new_rec->is_allocation_record()) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
582 if (!reserved_rec->is_same_region(new_rec)) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
583 // only deal with split a bigger reserved region into smaller regions. |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
584 // So far, CDS is the only use case. |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
585 if (!vm_snapshot_itr.split_reserved_region(reserved_rec, new_rec->addr(), new_rec->size())) { |
6741
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
586 return false; |
6197 | 587 } |
588 } | |
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
589 } else if (new_rec->is_uncommit_record()) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
590 if (!vm_snapshot_itr.remove_uncommitted_region(new_rec)) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
591 return false; |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
592 } |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
593 } else if (new_rec->is_commit_record()) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
594 // insert or expand existing committed region to cover this |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
595 // newly committed region |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
596 if (!vm_snapshot_itr.add_committed_region(new_rec)) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
597 return false; |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
598 } |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
599 } else if (new_rec->is_deallocation_record()) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
600 // release part or all memory region |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
601 if (!vm_snapshot_itr.remove_released_region(new_rec)) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
602 return false; |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
603 } |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
604 } else if (new_rec->is_type_tagging_record()) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
605 // tag this reserved virtual memory range to a memory type. Can not re-tag a memory range |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
606 // to different type. |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
607 assert(FLAGS_TO_MEMORY_TYPE(reserved_rec->flags()) == mtNone || |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
608 FLAGS_TO_MEMORY_TYPE(reserved_rec->flags()) == FLAGS_TO_MEMORY_TYPE(new_rec->flags()), |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
609 "Sanity check"); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
610 reserved_rec->tag(new_rec->flags()); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
611 } else { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
612 ShouldNotReachHere(); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
613 } |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
614 } else { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
615 /* |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
616 * The assertion failure indicates mis-matched virtual memory records. The likely |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
617 * scenario is, that some virtual memory operations are not going through os::xxxx_memory() |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
618 * api, which have to be tracked manually. (perfMemory is an example). |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
619 */ |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
620 assert(new_rec->is_allocation_record(), "Sanity check"); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
621 if (!vm_snapshot_itr.add_reserved_region(new_rec)) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
622 return false; |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
623 } |
6741
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
624 } |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
625 new_rec = (MemPointerRecord*)itr->next(); |
6197 | 626 } |
6741
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
627 return true; |
6197 | 628 } |
629 | |
6607
e5bf1c79ed5b
7191124: Optimized build is broken due to inconsistent use of DEBUG_ONLY and NOT_PRODUCT macros in NMT
zgu
parents:
6599
diff
changeset
|
630 #ifndef PRODUCT |
6197 | 631 void MemSnapshot::print_snapshot_stats(outputStream* st) { |
632 st->print_cr("Snapshot:"); | |
633 st->print_cr("\tMalloced: %d/%d [%5.2f%%] %dKB", _alloc_ptrs->length(), _alloc_ptrs->capacity(), | |
634 (100.0 * (float)_alloc_ptrs->length()) / (float)_alloc_ptrs->capacity(), _alloc_ptrs->instance_size()/K); | |
635 | |
636 st->print_cr("\tVM: %d/%d [%5.2f%%] %dKB", _vm_ptrs->length(), _vm_ptrs->capacity(), | |
637 (100.0 * (float)_vm_ptrs->length()) / (float)_vm_ptrs->capacity(), _vm_ptrs->instance_size()/K); | |
638 | |
6741
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
639 st->print_cr("\tMalloc staging Area: %d/%d [%5.2f%%] %dKB", _staging_area.malloc_data()->length(), |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
640 _staging_area.malloc_data()->capacity(), |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
641 (100.0 * (float)_staging_area.malloc_data()->length()) / (float)_staging_area.malloc_data()->capacity(), |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
642 _staging_area.malloc_data()->instance_size()/K); |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
643 |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
644 st->print_cr("\tVirtual memory staging Area: %d/%d [%5.2f%%] %dKB", _staging_area.vm_data()->length(), |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
645 _staging_area.vm_data()->capacity(), |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
646 (100.0 * (float)_staging_area.vm_data()->length()) / (float)_staging_area.vm_data()->capacity(), |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
647 _staging_area.vm_data()->instance_size()/K); |
6197 | 648 |
649 st->print_cr("\tUntracked allocation: %d", _untracked_count); | |
650 } | |
651 | |
652 void MemSnapshot::check_malloc_pointers() { | |
653 MemPointerArrayIteratorImpl mItr(_alloc_ptrs); | |
654 MemPointerRecord* p = (MemPointerRecord*)mItr.current(); | |
655 MemPointerRecord* prev = NULL; | |
656 while (p != NULL) { | |
657 if (prev != NULL) { | |
658 assert(p->addr() >= prev->addr(), "sorting order"); | |
659 } | |
660 prev = p; | |
661 p = (MemPointerRecord*)mItr.next(); | |
662 } | |
663 } | |
664 | |
6607
e5bf1c79ed5b
7191124: Optimized build is broken due to inconsistent use of DEBUG_ONLY and NOT_PRODUCT macros in NMT
zgu
parents:
6599
diff
changeset
|
665 bool MemSnapshot::has_allocation_record(address addr) { |
6741
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
666 MemPointerArrayIteratorImpl itr(_staging_area.malloc_data()); |
6607
e5bf1c79ed5b
7191124: Optimized build is broken due to inconsistent use of DEBUG_ONLY and NOT_PRODUCT macros in NMT
zgu
parents:
6599
diff
changeset
|
667 MemPointerRecord* cur = (MemPointerRecord*)itr.current(); |
e5bf1c79ed5b
7191124: Optimized build is broken due to inconsistent use of DEBUG_ONLY and NOT_PRODUCT macros in NMT
zgu
parents:
6599
diff
changeset
|
668 while (cur != NULL) { |
e5bf1c79ed5b
7191124: Optimized build is broken due to inconsistent use of DEBUG_ONLY and NOT_PRODUCT macros in NMT
zgu
parents:
6599
diff
changeset
|
669 if (cur->addr() == addr && cur->is_allocation_record()) { |
e5bf1c79ed5b
7191124: Optimized build is broken due to inconsistent use of DEBUG_ONLY and NOT_PRODUCT macros in NMT
zgu
parents:
6599
diff
changeset
|
670 return true; |
e5bf1c79ed5b
7191124: Optimized build is broken due to inconsistent use of DEBUG_ONLY and NOT_PRODUCT macros in NMT
zgu
parents:
6599
diff
changeset
|
671 } |
e5bf1c79ed5b
7191124: Optimized build is broken due to inconsistent use of DEBUG_ONLY and NOT_PRODUCT macros in NMT
zgu
parents:
6599
diff
changeset
|
672 cur = (MemPointerRecord*)itr.next(); |
e5bf1c79ed5b
7191124: Optimized build is broken due to inconsistent use of DEBUG_ONLY and NOT_PRODUCT macros in NMT
zgu
parents:
6599
diff
changeset
|
673 } |
e5bf1c79ed5b
7191124: Optimized build is broken due to inconsistent use of DEBUG_ONLY and NOT_PRODUCT macros in NMT
zgu
parents:
6599
diff
changeset
|
674 return false; |
e5bf1c79ed5b
7191124: Optimized build is broken due to inconsistent use of DEBUG_ONLY and NOT_PRODUCT macros in NMT
zgu
parents:
6599
diff
changeset
|
675 } |
e5bf1c79ed5b
7191124: Optimized build is broken due to inconsistent use of DEBUG_ONLY and NOT_PRODUCT macros in NMT
zgu
parents:
6599
diff
changeset
|
676 #endif // PRODUCT |
e5bf1c79ed5b
7191124: Optimized build is broken due to inconsistent use of DEBUG_ONLY and NOT_PRODUCT macros in NMT
zgu
parents:
6599
diff
changeset
|
677 |
e5bf1c79ed5b
7191124: Optimized build is broken due to inconsistent use of DEBUG_ONLY and NOT_PRODUCT macros in NMT
zgu
parents:
6599
diff
changeset
|
678 #ifdef ASSERT |
6197 | 679 void MemSnapshot::check_staging_data() { |
6741
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
680 MemPointerArrayIteratorImpl itr(_staging_area.malloc_data()); |
6197 | 681 MemPointerRecord* cur = (MemPointerRecord*)itr.current(); |
682 MemPointerRecord* next = (MemPointerRecord*)itr.next(); | |
683 while (next != NULL) { | |
684 assert((next->addr() > cur->addr()) || | |
685 ((next->flags() & MemPointerRecord::tag_masks) > | |
686 (cur->flags() & MemPointerRecord::tag_masks)), | |
687 "sorting order"); | |
688 cur = next; | |
689 next = (MemPointerRecord*)itr.next(); | |
690 } | |
6741
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
691 |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
692 MemPointerArrayIteratorImpl vm_itr(_staging_area.vm_data()); |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
693 cur = (MemPointerRecord*)vm_itr.current(); |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
694 while (cur != NULL) { |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
695 assert(cur->is_vm_pointer(), "virtual memory pointer only"); |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
696 cur = (MemPointerRecord*)vm_itr.next(); |
33143ee07800
7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() || cur_vm->is_deallocation_record
zgu
parents:
6607
diff
changeset
|
697 } |
6197 | 698 } |
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
699 |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
700 void MemSnapshot::dump_all_vm_pointers() { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
701 MemPointerArrayIteratorImpl itr(_vm_ptrs); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
702 VMMemRegion* ptr = (VMMemRegion*)itr.current(); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
703 tty->print_cr("dump virtual memory pointers:"); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
704 while (ptr != NULL) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
705 if (ptr->is_committed_region()) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
706 tty->print("\t"); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
707 } |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
708 tty->print("[" PTR_FORMAT " - " PTR_FORMAT "] [%x]", ptr->addr(), |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
709 (ptr->addr() + ptr->size()), ptr->flags()); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
710 |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
711 if (MemTracker::track_callsite()) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
712 VMMemRegionEx* ex = (VMMemRegionEx*)ptr; |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
713 if (ex->pc() != NULL) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
714 char buf[1024]; |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
715 if (os::dll_address_to_function_name(ex->pc(), buf, sizeof(buf), NULL)) { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
716 tty->print_cr("\t%s", buf); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
717 } else { |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
718 tty->print_cr(""); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
719 } |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
720 } |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
721 } |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
722 |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
723 ptr = (VMMemRegion*)itr.next(); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
724 } |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
725 tty->flush(); |
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6741
diff
changeset
|
726 } |
6607
e5bf1c79ed5b
7191124: Optimized build is broken due to inconsistent use of DEBUG_ONLY and NOT_PRODUCT macros in NMT
zgu
parents:
6599
diff
changeset
|
727 #endif // ASSERT |
6197 | 728 |