1 /*
2 * Copyright (c) 2013, 2019, 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 #ifndef SHARE_SERVICES_MEMTRACKER_HPP
26 #define SHARE_SERVICES_MEMTRACKER_HPP
27
28 #include "services/nmtCommon.hpp"
29 #include "utilities/nativeCallStack.hpp"
30
31
32 #if !INCLUDE_NMT
33
34 #define CURRENT_PC NativeCallStack::empty_stack()
35 #define CALLER_PC NativeCallStack::empty_stack()
36
37 class Tracker : public StackObj {
38 public:
39 enum TrackerType {
40 uncommit,
41 release
42 };
43 Tracker(enum TrackerType type) : _type(type) { }
44 void record(address addr, size_t size) { }
45 private:
46 enum TrackerType _type;
47 };
48
49 class MemTracker : AllStatic {
50 public:
51 static inline NMT_TrackingLevel tracking_level() { return NMT_off; }
52 static inline void shutdown() { }
53 static inline void init() { }
54 static bool check_launcher_nmt_support(const char* value) { return true; }
55 static bool verify_nmt_option() { return true; }
56
57 static inline void* record_malloc(void* mem_base, size_t size, MEMFLAGS flag,
58 const NativeCallStack& stack, NMT_TrackingLevel level) { return mem_base; }
59 static inline size_t malloc_header_size(NMT_TrackingLevel level) { return 0; }
60 static inline size_t malloc_header_size(void* memblock) { return 0; }
61 static inline void* malloc_base(void* memblock) { return memblock; }
62 static inline void* record_free(void* memblock, NMT_TrackingLevel level) { return memblock; }
63
64 static inline void record_new_arena(MEMFLAGS flag) { }
65 static inline void record_arena_free(MEMFLAGS flag) { }
66 static inline void record_arena_size_change(ssize_t diff, MEMFLAGS flag) { }
67 static inline void record_virtual_memory_reserve(void* addr, size_t size, const NativeCallStack& stack,
68 MEMFLAGS flag = mtNone) { }
69 static inline void record_virtual_memory_reserve_and_commit(void* addr, size_t size,
70 const NativeCallStack& stack, MEMFLAGS flag = mtNone) { }
71 static inline void record_virtual_memory_commit(void* addr, size_t size, const NativeCallStack& stack) { }
72 static inline void record_virtual_memory_type(void* addr, MEMFLAGS flag) { }
73 static inline void record_thread_stack(void* addr, size_t size) { }
74 static inline void release_thread_stack(void* addr, size_t size) { }
75
76 static void final_report(outputStream*) { }
77 static void error_report(outputStream*) { }
78 };
79
80 #else
81
82 #include "runtime/mutexLocker.hpp"
83 #include "runtime/threadCritical.hpp"
84 #include "services/mallocTracker.hpp"
85 #include "services/threadStackTracker.hpp"
86 #include "services/virtualMemoryTracker.hpp"
87
88 #define CURRENT_PC ((MemTracker::tracking_level() == NMT_detail) ? \
89 NativeCallStack(0, true) : NativeCallStack::empty_stack())
90 #define CALLER_PC ((MemTracker::tracking_level() == NMT_detail) ? \
91 NativeCallStack(1, true) : NativeCallStack::empty_stack())
92
93 class MemBaseline;
94
95 // Tracker is used for guarding 'release' semantics of virtual memory operation, to avoid
96 // the other thread obtains and records the same region that is just 'released' by current
97 // thread but before it can record the operation.
98 class Tracker : public StackObj {
99 public:
100 enum TrackerType {
101 uncommit,
102 release
103 };
104
105 public:
106 Tracker(enum TrackerType type) : _type(type) { }
107 void record(address addr, size_t size);
108 private:
109 enum TrackerType _type;
110 // Virtual memory tracking data structures are protected by ThreadCritical lock.
111 ThreadCritical _tc;
112 };
113
114 class MemTracker : AllStatic {
115 friend class VirtualMemoryTrackerTest;
116
117 public:
118 static inline NMT_TrackingLevel tracking_level() {
119 if (_tracking_level == NMT_unknown) {
120 // No fencing is needed here, since JVM is in single-threaded
121 // mode.
122 _tracking_level = init_tracking_level();
123 _cmdline_tracking_level = _tracking_level;
124 }
125 return _tracking_level;
126 }
127
128 // A late initialization, for the stuff(s) can not be
129 // done in init_tracking_level(), which can NOT malloc
130 // any memory.
131 static void init();
132
133 // Shutdown native memory tracking
134 static void shutdown();
135
136 // Verify native memory tracking command line option.
137 // This check allows JVM to detect if compatible launcher
138 // is used.
139 // If an incompatible launcher is used, NMT may not be
140 // able to start, even it is enabled by command line option.
141 // A warning message should be given if it is encountered.
142 static bool check_launcher_nmt_support(const char* value);
143
144 // This method checks native memory tracking environment
145 // variable value passed by launcher.
146 // Launcher only obligated to pass native memory tracking
147 // option value, but not obligated to validate the value,
148 // and launcher has option to discard native memory tracking
149 // option from the command line once it sets up the environment
150 // variable, so NMT has to catch the bad value here.
151 static bool verify_nmt_option();
152
153 // Transition the tracking level to specified level
154 static bool transition_to(NMT_TrackingLevel level);
155
156 static inline void* record_malloc(void* mem_base, size_t size, MEMFLAGS flag,
157 const NativeCallStack& stack, NMT_TrackingLevel level) {
158 if (level != NMT_off) {
159 return MallocTracker::record_malloc(mem_base, size, flag, stack, level);
160 }
161 return mem_base;
162 }
163
164 static inline size_t malloc_header_size(NMT_TrackingLevel level) {
165 return MallocTracker::malloc_header_size(level);
166 }
167
168 static size_t malloc_header_size(void* memblock) {
169 if (tracking_level() != NMT_off) {
170 return MallocTracker::get_header_size(memblock);
171 }
172 return 0;
173 }
174
175 // To malloc base address, which is the starting address
176 // of malloc tracking header if tracking is enabled.
177 // Otherwise, it returns the same address.
178 static void* malloc_base(void* memblock);
179
180 // Record malloc free and return malloc base address
181 static inline void* record_free(void* memblock, NMT_TrackingLevel level) {
182 // Never turned on
183 if (level == NMT_off || memblock == NULL) {
184 return memblock;
185 }
186 return MallocTracker::record_free(memblock);
187 }
188
189
190 // Record creation of an arena
191 static inline void record_new_arena(MEMFLAGS flag) {
192 if (tracking_level() < NMT_summary) return;
193 MallocTracker::record_new_arena(flag);
194 }
195
196 // Record destruction of an arena
197 static inline void record_arena_free(MEMFLAGS flag) {
198 if (tracking_level() < NMT_summary) return;
199 MallocTracker::record_arena_free(flag);
200 }
201
202 // Record arena size change. Arena size is the size of all arena
203 // chuncks that backing up the arena.
204 static inline void record_arena_size_change(ssize_t diff, MEMFLAGS flag) {
205 if (tracking_level() < NMT_summary) return;
206 MallocTracker::record_arena_size_change(diff, flag);
207 }
208
209 static inline void record_virtual_memory_reserve(void* addr, size_t size, const NativeCallStack& stack,
210 MEMFLAGS flag = mtNone) {
211 if (tracking_level() < NMT_summary) return;
212 if (addr != NULL) {
213 ThreadCritical tc;
214 // Recheck to avoid potential racing during NMT shutdown
215 if (tracking_level() < NMT_summary) return;
216 VirtualMemoryTracker::add_reserved_region((address)addr, size, stack, flag);
217 }
218 }
219
220 static inline void record_virtual_memory_reserve_and_commit(void* addr, size_t size,
221 const NativeCallStack& stack, MEMFLAGS flag = mtNone) {
222 if (tracking_level() < NMT_summary) return;
223 if (addr != NULL) {
224 ThreadCritical tc;
225 if (tracking_level() < NMT_summary) return;
226 VirtualMemoryTracker::add_reserved_region((address)addr, size, stack, flag);
227 VirtualMemoryTracker::add_committed_region((address)addr, size, stack);
228 }
229 }
230
231 static inline void record_virtual_memory_commit(void* addr, size_t size,
232 const NativeCallStack& stack) {
233 if (tracking_level() < NMT_summary) return;
234 if (addr != NULL) {
235 ThreadCritical tc;
236 if (tracking_level() < NMT_summary) return;
237 VirtualMemoryTracker::add_committed_region((address)addr, size, stack);
238 }
239 }
240
241 static inline void record_virtual_memory_type(void* addr, MEMFLAGS flag) {
242 if (tracking_level() < NMT_summary) return;
243 if (addr != NULL) {
244 ThreadCritical tc;
245 if (tracking_level() < NMT_summary) return;
246 VirtualMemoryTracker::set_reserved_region_type((address)addr, flag);
247 }
248 }
249
250 static void record_thread_stack(void* addr, size_t size) {
251 if (tracking_level() < NMT_summary) return;
252 if (addr != NULL) {
253 ThreadStackTracker::new_thread_stack((address)addr, size, CALLER_PC);
254 }
255 }
256
257 static inline void release_thread_stack(void* addr, size_t size) {
258 if (tracking_level() < NMT_summary) return;
259 if (addr != NULL) {
260 ThreadStackTracker::delete_thread_stack((address)addr, size);
261 }
262 }
263
264 // Query lock is used to synchronize the access to tracking data.
265 // So far, it is only used by JCmd query, but it may be used by
266 // other tools.
267 static inline Mutex* query_lock() {
268 assert(NMTQuery_lock != NULL, "not initialized!");
269 return NMTQuery_lock;
270 }
271
272 // Make a final report or report for hs_err file.
273 static void error_report(outputStream* output) {
274 if (tracking_level() >= NMT_summary) {
275 report(true, output); // just print summary for error case.
276 }
277 }
278
279 static void final_report(outputStream* output);
280
281 // Stored baseline
282 static inline MemBaseline& get_baseline() {
283 return _baseline;
284 }
285
286 static NMT_TrackingLevel cmdline_tracking_level() {
287 return _cmdline_tracking_level;
288 }
289
290 static void tuning_statistics(outputStream* out);
291
292 private:
293 static NMT_TrackingLevel init_tracking_level();
294 static void report(bool summary_only, outputStream* output);
295
296 private:
297 // Tracking level
298 static volatile NMT_TrackingLevel _tracking_level;
299 // If NMT option value passed by launcher through environment
300 // variable is valid
301 static bool _is_nmt_env_valid;
302 // command line tracking level
303 static NMT_TrackingLevel _cmdline_tracking_level;
304 // Stored baseline
305 static MemBaseline _baseline;
306 // Query lock
307 static Mutex* _query_lock;
308 };
309
310 #endif // INCLUDE_NMT
311
312 #endif // SHARE_SERVICES_MEMTRACKER_HPP