96 // Tracker is used for guarding 'release' semantics of virtual memory operation, to avoid
97 // the other thread obtains and records the same region that is just 'released' by current
98 // thread but before it can record the operation.
99 class Tracker : public StackObj {
100 public:
101 enum TrackerType {
102 uncommit,
103 release
104 };
105
106 public:
107 Tracker(enum TrackerType type) : _type(type) { }
108 void record(address addr, size_t size);
109 private:
110 enum TrackerType _type;
111 // Virtual memory tracking data structures are protected by ThreadCritical lock.
112 ThreadCritical _tc;
113 };
114
115 class MemTracker : AllStatic {
116 public:
117 static inline NMT_TrackingLevel tracking_level() {
118 if (_tracking_level == NMT_unknown) {
119 // No fencing is needed here, since JVM is in single-threaded
120 // mode.
121 _tracking_level = init_tracking_level();
122 _cmdline_tracking_level = _tracking_level;
123 }
124 return _tracking_level;
125 }
126
127 // A late initialization, for the stuff(s) can not be
128 // done in init_tracking_level(), which can NOT malloc
129 // any memory.
130 static void init();
131
132 // Shutdown native memory tracking
133 static void shutdown();
134
135 // Verify native memory tracking command line option.
198 MallocTracker::record_arena_size_change(diff, flag);
199 }
200
201 static inline void record_virtual_memory_reserve(void* addr, size_t size, const NativeCallStack& stack,
202 MEMFLAGS flag = mtNone) {
203 if (tracking_level() < NMT_summary) return;
204 if (addr != NULL) {
205 ThreadCritical tc;
206 // Recheck to avoid potential racing during NMT shutdown
207 if (tracking_level() < NMT_summary) return;
208 VirtualMemoryTracker::add_reserved_region((address)addr, size, stack, flag);
209 }
210 }
211
212 static inline void record_virtual_memory_reserve_and_commit(void* addr, size_t size,
213 const NativeCallStack& stack, MEMFLAGS flag = mtNone) {
214 if (tracking_level() < NMT_summary) return;
215 if (addr != NULL) {
216 ThreadCritical tc;
217 if (tracking_level() < NMT_summary) return;
218 VirtualMemoryTracker::add_reserved_region((address)addr, size,
219 stack, flag, true);
220 VirtualMemoryTracker::add_committed_region((address)addr, size, stack);
221 }
222 }
223
224 static inline void record_virtual_memory_commit(void* addr, size_t size,
225 const NativeCallStack& stack) {
226 if (tracking_level() < NMT_summary) return;
227 if (addr != NULL) {
228 ThreadCritical tc;
229 if (tracking_level() < NMT_summary) return;
230 VirtualMemoryTracker::add_committed_region((address)addr, size, stack);
231 }
232 }
233
234 static inline void record_virtual_memory_type(void* addr, MEMFLAGS flag) {
235 if (tracking_level() < NMT_summary) return;
236 if (addr != NULL) {
237 ThreadCritical tc;
238 if (tracking_level() < NMT_summary) return;
239 VirtualMemoryTracker::set_reserved_region_type((address)addr, flag);
|
96 // Tracker is used for guarding 'release' semantics of virtual memory operation, to avoid
97 // the other thread obtains and records the same region that is just 'released' by current
98 // thread but before it can record the operation.
99 class Tracker : public StackObj {
100 public:
101 enum TrackerType {
102 uncommit,
103 release
104 };
105
106 public:
107 Tracker(enum TrackerType type) : _type(type) { }
108 void record(address addr, size_t size);
109 private:
110 enum TrackerType _type;
111 // Virtual memory tracking data structures are protected by ThreadCritical lock.
112 ThreadCritical _tc;
113 };
114
115 class MemTracker : AllStatic {
116 friend class VirtualMemoryTrackerTest;
117
118 public:
119 static inline NMT_TrackingLevel tracking_level() {
120 if (_tracking_level == NMT_unknown) {
121 // No fencing is needed here, since JVM is in single-threaded
122 // mode.
123 _tracking_level = init_tracking_level();
124 _cmdline_tracking_level = _tracking_level;
125 }
126 return _tracking_level;
127 }
128
129 // A late initialization, for the stuff(s) can not be
130 // done in init_tracking_level(), which can NOT malloc
131 // any memory.
132 static void init();
133
134 // Shutdown native memory tracking
135 static void shutdown();
136
137 // Verify native memory tracking command line option.
200 MallocTracker::record_arena_size_change(diff, flag);
201 }
202
203 static inline void record_virtual_memory_reserve(void* addr, size_t size, const NativeCallStack& stack,
204 MEMFLAGS flag = mtNone) {
205 if (tracking_level() < NMT_summary) return;
206 if (addr != NULL) {
207 ThreadCritical tc;
208 // Recheck to avoid potential racing during NMT shutdown
209 if (tracking_level() < NMT_summary) return;
210 VirtualMemoryTracker::add_reserved_region((address)addr, size, stack, flag);
211 }
212 }
213
214 static inline void record_virtual_memory_reserve_and_commit(void* addr, size_t size,
215 const NativeCallStack& stack, MEMFLAGS flag = mtNone) {
216 if (tracking_level() < NMT_summary) return;
217 if (addr != NULL) {
218 ThreadCritical tc;
219 if (tracking_level() < NMT_summary) return;
220 VirtualMemoryTracker::add_reserved_region((address)addr, size, stack, flag);
221 VirtualMemoryTracker::add_committed_region((address)addr, size, stack);
222 }
223 }
224
225 static inline void record_virtual_memory_commit(void* addr, size_t size,
226 const NativeCallStack& stack) {
227 if (tracking_level() < NMT_summary) return;
228 if (addr != NULL) {
229 ThreadCritical tc;
230 if (tracking_level() < NMT_summary) return;
231 VirtualMemoryTracker::add_committed_region((address)addr, size, stack);
232 }
233 }
234
235 static inline void record_virtual_memory_type(void* addr, MEMFLAGS flag) {
236 if (tracking_level() < NMT_summary) return;
237 if (addr != NULL) {
238 ThreadCritical tc;
239 if (tracking_level() < NMT_summary) return;
240 VirtualMemoryTracker::set_reserved_region_type((address)addr, flag);
|