1
|
1 |
/*
|
|
2 |
* Copyright 2003-2007 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
|
20 |
* CA 95054 USA or visit www.sun.com if you need additional information or
|
|
21 |
* have any questions.
|
|
22 |
*
|
|
23 |
*/
|
|
24 |
|
|
25 |
# include "incls/_precompiled.incl"
|
|
26 |
# include "incls/_management.cpp.incl"
|
|
27 |
|
|
28 |
PerfVariable* Management::_begin_vm_creation_time = NULL;
|
|
29 |
PerfVariable* Management::_end_vm_creation_time = NULL;
|
|
30 |
PerfVariable* Management::_vm_init_done_time = NULL;
|
|
31 |
|
|
32 |
klassOop Management::_sensor_klass = NULL;
|
|
33 |
klassOop Management::_threadInfo_klass = NULL;
|
|
34 |
klassOop Management::_memoryUsage_klass = NULL;
|
|
35 |
klassOop Management::_memoryPoolMXBean_klass = NULL;
|
|
36 |
klassOop Management::_memoryManagerMXBean_klass = NULL;
|
|
37 |
klassOop Management::_garbageCollectorMXBean_klass = NULL;
|
|
38 |
klassOop Management::_managementFactory_klass = NULL;
|
|
39 |
|
|
40 |
jmmOptionalSupport Management::_optional_support = {0};
|
|
41 |
TimeStamp Management::_stamp;
|
|
42 |
|
|
43 |
void management_init() {
|
|
44 |
Management::init();
|
|
45 |
ThreadService::init();
|
|
46 |
RuntimeService::init();
|
|
47 |
ClassLoadingService::init();
|
|
48 |
}
|
|
49 |
|
|
50 |
void Management::init() {
|
|
51 |
EXCEPTION_MARK;
|
|
52 |
|
|
53 |
// These counters are for java.lang.management API support.
|
|
54 |
// They are created even if -XX:-UsePerfData is set and in
|
|
55 |
// that case, they will be allocated on C heap.
|
|
56 |
|
|
57 |
_begin_vm_creation_time =
|
|
58 |
PerfDataManager::create_variable(SUN_RT, "createVmBeginTime",
|
|
59 |
PerfData::U_None, CHECK);
|
|
60 |
|
|
61 |
_end_vm_creation_time =
|
|
62 |
PerfDataManager::create_variable(SUN_RT, "createVmEndTime",
|
|
63 |
PerfData::U_None, CHECK);
|
|
64 |
|
|
65 |
_vm_init_done_time =
|
|
66 |
PerfDataManager::create_variable(SUN_RT, "vmInitDoneTime",
|
|
67 |
PerfData::U_None, CHECK);
|
|
68 |
|
|
69 |
// Initialize optional support
|
|
70 |
_optional_support.isLowMemoryDetectionSupported = 1;
|
|
71 |
_optional_support.isCompilationTimeMonitoringSupported = 1;
|
|
72 |
_optional_support.isThreadContentionMonitoringSupported = 1;
|
|
73 |
|
|
74 |
if (os::is_thread_cpu_time_supported()) {
|
|
75 |
_optional_support.isCurrentThreadCpuTimeSupported = 1;
|
|
76 |
_optional_support.isOtherThreadCpuTimeSupported = 1;
|
|
77 |
} else {
|
|
78 |
_optional_support.isCurrentThreadCpuTimeSupported = 0;
|
|
79 |
_optional_support.isOtherThreadCpuTimeSupported = 0;
|
|
80 |
}
|
|
81 |
_optional_support.isBootClassPathSupported = 1;
|
|
82 |
_optional_support.isObjectMonitorUsageSupported = 1;
|
|
83 |
#ifndef SERVICES_KERNEL
|
|
84 |
// This depends on the heap inspector
|
|
85 |
_optional_support.isSynchronizerUsageSupported = 1;
|
|
86 |
#endif // SERVICES_KERNEL
|
|
87 |
}
|
|
88 |
|
|
89 |
void Management::initialize(TRAPS) {
|
|
90 |
// Start the low memory detector thread
|
|
91 |
LowMemoryDetector::initialize();
|
|
92 |
|
|
93 |
if (ManagementServer) {
|
|
94 |
ResourceMark rm(THREAD);
|
|
95 |
HandleMark hm(THREAD);
|
|
96 |
|
|
97 |
// Load and initialize the sun.management.Agent class
|
|
98 |
// invoke startAgent method to start the management server
|
|
99 |
Handle loader = Handle(THREAD, SystemDictionary::java_system_loader());
|
|
100 |
klassOop k = SystemDictionary::resolve_or_fail(vmSymbolHandles::sun_management_Agent(),
|
|
101 |
loader,
|
|
102 |
Handle(),
|
|
103 |
true,
|
|
104 |
CHECK);
|
|
105 |
instanceKlassHandle ik (THREAD, k);
|
|
106 |
|
|
107 |
JavaValue result(T_VOID);
|
|
108 |
JavaCalls::call_static(&result,
|
|
109 |
ik,
|
|
110 |
vmSymbolHandles::startAgent_name(),
|
|
111 |
vmSymbolHandles::void_method_signature(),
|
|
112 |
CHECK);
|
|
113 |
}
|
|
114 |
}
|
|
115 |
|
|
116 |
void Management::get_optional_support(jmmOptionalSupport* support) {
|
|
117 |
memcpy(support, &_optional_support, sizeof(jmmOptionalSupport));
|
|
118 |
}
|
|
119 |
|
|
120 |
klassOop Management::load_and_initialize_klass(symbolHandle sh, TRAPS) {
|
|
121 |
klassOop k = SystemDictionary::resolve_or_fail(sh, true, CHECK_NULL);
|
|
122 |
instanceKlassHandle ik (THREAD, k);
|
|
123 |
if (ik->should_be_initialized()) {
|
|
124 |
ik->initialize(CHECK_NULL);
|
|
125 |
}
|
|
126 |
return ik();
|
|
127 |
}
|
|
128 |
|
|
129 |
void Management::record_vm_startup_time(jlong begin, jlong duration) {
|
|
130 |
// if the performance counter is not initialized,
|
|
131 |
// then vm initialization failed; simply return.
|
|
132 |
if (_begin_vm_creation_time == NULL) return;
|
|
133 |
|
|
134 |
_begin_vm_creation_time->set_value(begin);
|
|
135 |
_end_vm_creation_time->set_value(begin + duration);
|
|
136 |
PerfMemory::set_accessible(true);
|
|
137 |
}
|
|
138 |
|
|
139 |
jlong Management::timestamp() {
|
|
140 |
TimeStamp t;
|
|
141 |
t.update();
|
|
142 |
return t.ticks() - _stamp.ticks();
|
|
143 |
}
|
|
144 |
|
|
145 |
void Management::oops_do(OopClosure* f) {
|
|
146 |
MemoryService::oops_do(f);
|
|
147 |
ThreadService::oops_do(f);
|
|
148 |
|
|
149 |
f->do_oop((oop*) &_sensor_klass);
|
|
150 |
f->do_oop((oop*) &_threadInfo_klass);
|
|
151 |
f->do_oop((oop*) &_memoryUsage_klass);
|
|
152 |
f->do_oop((oop*) &_memoryPoolMXBean_klass);
|
|
153 |
f->do_oop((oop*) &_memoryManagerMXBean_klass);
|
|
154 |
f->do_oop((oop*) &_garbageCollectorMXBean_klass);
|
|
155 |
f->do_oop((oop*) &_managementFactory_klass);
|
|
156 |
}
|
|
157 |
|
|
158 |
klassOop Management::java_lang_management_ThreadInfo_klass(TRAPS) {
|
|
159 |
if (_threadInfo_klass == NULL) {
|
|
160 |
_threadInfo_klass = load_and_initialize_klass(vmSymbolHandles::java_lang_management_ThreadInfo(), CHECK_NULL);
|
|
161 |
}
|
|
162 |
return _threadInfo_klass;
|
|
163 |
}
|
|
164 |
|
|
165 |
klassOop Management::java_lang_management_MemoryUsage_klass(TRAPS) {
|
|
166 |
if (_memoryUsage_klass == NULL) {
|
|
167 |
_memoryUsage_klass = load_and_initialize_klass(vmSymbolHandles::java_lang_management_MemoryUsage(), CHECK_NULL);
|
|
168 |
}
|
|
169 |
return _memoryUsage_klass;
|
|
170 |
}
|
|
171 |
|
|
172 |
klassOop Management::java_lang_management_MemoryPoolMXBean_klass(TRAPS) {
|
|
173 |
if (_memoryPoolMXBean_klass == NULL) {
|
|
174 |
_memoryPoolMXBean_klass = load_and_initialize_klass(vmSymbolHandles::java_lang_management_MemoryPoolMXBean(), CHECK_NULL);
|
|
175 |
}
|
|
176 |
return _memoryPoolMXBean_klass;
|
|
177 |
}
|
|
178 |
|
|
179 |
klassOop Management::java_lang_management_MemoryManagerMXBean_klass(TRAPS) {
|
|
180 |
if (_memoryManagerMXBean_klass == NULL) {
|
|
181 |
_memoryManagerMXBean_klass = load_and_initialize_klass(vmSymbolHandles::java_lang_management_MemoryManagerMXBean(), CHECK_NULL);
|
|
182 |
}
|
|
183 |
return _memoryManagerMXBean_klass;
|
|
184 |
}
|
|
185 |
|
|
186 |
klassOop Management::java_lang_management_GarbageCollectorMXBean_klass(TRAPS) {
|
|
187 |
if (_garbageCollectorMXBean_klass == NULL) {
|
|
188 |
_garbageCollectorMXBean_klass = load_and_initialize_klass(vmSymbolHandles::java_lang_management_GarbageCollectorMXBean(), CHECK_NULL);
|
|
189 |
}
|
|
190 |
return _garbageCollectorMXBean_klass;
|
|
191 |
}
|
|
192 |
|
|
193 |
klassOop Management::sun_management_Sensor_klass(TRAPS) {
|
|
194 |
if (_sensor_klass == NULL) {
|
|
195 |
_sensor_klass = load_and_initialize_klass(vmSymbolHandles::sun_management_Sensor(), CHECK_NULL);
|
|
196 |
}
|
|
197 |
return _sensor_klass;
|
|
198 |
}
|
|
199 |
|
|
200 |
klassOop Management::sun_management_ManagementFactory_klass(TRAPS) {
|
|
201 |
if (_managementFactory_klass == NULL) {
|
|
202 |
_managementFactory_klass = load_and_initialize_klass(vmSymbolHandles::sun_management_ManagementFactory(), CHECK_NULL);
|
|
203 |
}
|
|
204 |
return _managementFactory_klass;
|
|
205 |
}
|
|
206 |
|
|
207 |
static void initialize_ThreadInfo_constructor_arguments(JavaCallArguments* args, ThreadSnapshot* snapshot, TRAPS) {
|
|
208 |
Handle snapshot_thread(THREAD, snapshot->threadObj());
|
|
209 |
|
|
210 |
jlong contended_time;
|
|
211 |
jlong waited_time;
|
|
212 |
if (ThreadService::is_thread_monitoring_contention()) {
|
|
213 |
contended_time = Management::ticks_to_ms(snapshot->contended_enter_ticks());
|
|
214 |
waited_time = Management::ticks_to_ms(snapshot->monitor_wait_ticks() + snapshot->sleep_ticks());
|
|
215 |
} else {
|
|
216 |
// set them to -1 if thread contention monitoring is disabled.
|
|
217 |
contended_time = max_julong;
|
|
218 |
waited_time = max_julong;
|
|
219 |
}
|
|
220 |
|
|
221 |
int thread_status = snapshot->thread_status();
|
|
222 |
assert((thread_status & JMM_THREAD_STATE_FLAG_MASK) == 0, "Flags already set in thread_status in Thread object");
|
|
223 |
if (snapshot->is_ext_suspended()) {
|
|
224 |
thread_status |= JMM_THREAD_STATE_FLAG_SUSPENDED;
|
|
225 |
}
|
|
226 |
if (snapshot->is_in_native()) {
|
|
227 |
thread_status |= JMM_THREAD_STATE_FLAG_NATIVE;
|
|
228 |
}
|
|
229 |
|
|
230 |
ThreadStackTrace* st = snapshot->get_stack_trace();
|
|
231 |
Handle stacktrace_h;
|
|
232 |
if (st != NULL) {
|
|
233 |
stacktrace_h = st->allocate_fill_stack_trace_element_array(CHECK);
|
|
234 |
} else {
|
|
235 |
stacktrace_h = Handle();
|
|
236 |
}
|
|
237 |
|
|
238 |
args->push_oop(snapshot_thread);
|
|
239 |
args->push_int(thread_status);
|
|
240 |
args->push_oop(Handle(THREAD, snapshot->blocker_object()));
|
|
241 |
args->push_oop(Handle(THREAD, snapshot->blocker_object_owner()));
|
|
242 |
args->push_long(snapshot->contended_enter_count());
|
|
243 |
args->push_long(contended_time);
|
|
244 |
args->push_long(snapshot->monitor_wait_count() + snapshot->sleep_count());
|
|
245 |
args->push_long(waited_time);
|
|
246 |
args->push_oop(stacktrace_h);
|
|
247 |
}
|
|
248 |
|
|
249 |
// Helper function to construct a ThreadInfo object
|
|
250 |
instanceOop Management::create_thread_info_instance(ThreadSnapshot* snapshot, TRAPS) {
|
|
251 |
klassOop k = Management::java_lang_management_ThreadInfo_klass(CHECK_NULL);
|
|
252 |
instanceKlassHandle ik (THREAD, k);
|
|
253 |
|
|
254 |
JavaValue result(T_VOID);
|
|
255 |
JavaCallArguments args(14);
|
|
256 |
|
|
257 |
// First allocate a ThreadObj object and
|
|
258 |
// push the receiver as the first argument
|
|
259 |
Handle element = ik->allocate_instance_handle(CHECK_NULL);
|
|
260 |
args.push_oop(element);
|
|
261 |
|
|
262 |
// initialize the arguments for the ThreadInfo constructor
|
|
263 |
initialize_ThreadInfo_constructor_arguments(&args, snapshot, CHECK_NULL);
|
|
264 |
|
|
265 |
// Call ThreadInfo constructor with no locked monitors and synchronizers
|
|
266 |
JavaCalls::call_special(&result,
|
|
267 |
ik,
|
|
268 |
vmSymbolHandles::object_initializer_name(),
|
|
269 |
vmSymbolHandles::java_lang_management_ThreadInfo_constructor_signature(),
|
|
270 |
&args,
|
|
271 |
CHECK_NULL);
|
|
272 |
|
|
273 |
return (instanceOop) element();
|
|
274 |
}
|
|
275 |
|
|
276 |
instanceOop Management::create_thread_info_instance(ThreadSnapshot* snapshot,
|
|
277 |
objArrayHandle monitors_array,
|
|
278 |
typeArrayHandle depths_array,
|
|
279 |
objArrayHandle synchronizers_array,
|
|
280 |
TRAPS) {
|
|
281 |
klassOop k = Management::java_lang_management_ThreadInfo_klass(CHECK_NULL);
|
|
282 |
instanceKlassHandle ik (THREAD, k);
|
|
283 |
|
|
284 |
JavaValue result(T_VOID);
|
|
285 |
JavaCallArguments args(17);
|
|
286 |
|
|
287 |
// First allocate a ThreadObj object and
|
|
288 |
// push the receiver as the first argument
|
|
289 |
Handle element = ik->allocate_instance_handle(CHECK_NULL);
|
|
290 |
args.push_oop(element);
|
|
291 |
|
|
292 |
// initialize the arguments for the ThreadInfo constructor
|
|
293 |
initialize_ThreadInfo_constructor_arguments(&args, snapshot, CHECK_NULL);
|
|
294 |
|
|
295 |
// push the locked monitors and synchronizers in the arguments
|
|
296 |
args.push_oop(monitors_array);
|
|
297 |
args.push_oop(depths_array);
|
|
298 |
args.push_oop(synchronizers_array);
|
|
299 |
|
|
300 |
// Call ThreadInfo constructor with locked monitors and synchronizers
|
|
301 |
JavaCalls::call_special(&result,
|
|
302 |
ik,
|
|
303 |
vmSymbolHandles::object_initializer_name(),
|
|
304 |
vmSymbolHandles::java_lang_management_ThreadInfo_with_locks_constructor_signature(),
|
|
305 |
&args,
|
|
306 |
CHECK_NULL);
|
|
307 |
|
|
308 |
return (instanceOop) element();
|
|
309 |
}
|
|
310 |
|
|
311 |
// Helper functions
|
|
312 |
static JavaThread* find_java_thread_from_id(jlong thread_id) {
|
|
313 |
assert(Threads_lock->owned_by_self(), "Must hold Threads_lock");
|
|
314 |
|
|
315 |
JavaThread* java_thread = NULL;
|
|
316 |
// Sequential search for now. Need to do better optimization later.
|
|
317 |
for (JavaThread* thread = Threads::first(); thread != NULL; thread = thread->next()) {
|
|
318 |
oop tobj = thread->threadObj();
|
|
319 |
if (!thread->is_exiting() &&
|
|
320 |
tobj != NULL &&
|
|
321 |
thread_id == java_lang_Thread::thread_id(tobj)) {
|
|
322 |
java_thread = thread;
|
|
323 |
break;
|
|
324 |
}
|
|
325 |
}
|
|
326 |
return java_thread;
|
|
327 |
}
|
|
328 |
|
|
329 |
static GCMemoryManager* get_gc_memory_manager_from_jobject(jobject mgr, TRAPS) {
|
|
330 |
if (mgr == NULL) {
|
|
331 |
THROW_(vmSymbols::java_lang_NullPointerException(), NULL);
|
|
332 |
}
|
|
333 |
oop mgr_obj = JNIHandles::resolve(mgr);
|
|
334 |
instanceHandle h(THREAD, (instanceOop) mgr_obj);
|
|
335 |
|
|
336 |
klassOop k = Management::java_lang_management_GarbageCollectorMXBean_klass(CHECK_NULL);
|
|
337 |
if (!h->is_a(k)) {
|
|
338 |
THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
|
|
339 |
"the object is not an instance of java.lang.management.GarbageCollectorMXBean class",
|
|
340 |
NULL);
|
|
341 |
}
|
|
342 |
|
|
343 |
MemoryManager* gc = MemoryService::get_memory_manager(h);
|
|
344 |
if (gc == NULL || !gc->is_gc_memory_manager()) {
|
|
345 |
THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
|
|
346 |
"Invalid GC memory manager",
|
|
347 |
NULL);
|
|
348 |
}
|
|
349 |
return (GCMemoryManager*) gc;
|
|
350 |
}
|
|
351 |
|
|
352 |
static MemoryPool* get_memory_pool_from_jobject(jobject obj, TRAPS) {
|
|
353 |
if (obj == NULL) {
|
|
354 |
THROW_(vmSymbols::java_lang_NullPointerException(), NULL);
|
|
355 |
}
|
|
356 |
|
|
357 |
oop pool_obj = JNIHandles::resolve(obj);
|
|
358 |
assert(pool_obj->is_instance(), "Should be an instanceOop");
|
|
359 |
instanceHandle ph(THREAD, (instanceOop) pool_obj);
|
|
360 |
|
|
361 |
return MemoryService::get_memory_pool(ph);
|
|
362 |
}
|
|
363 |
|
|
364 |
static void validate_thread_id_array(typeArrayHandle ids_ah, TRAPS) {
|
|
365 |
int num_threads = ids_ah->length();
|
|
366 |
// should be non-empty array
|
|
367 |
if (num_threads == 0) {
|
|
368 |
THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
|
|
369 |
"Empty array of thread IDs");
|
|
370 |
}
|
|
371 |
|
|
372 |
// Validate input thread IDs
|
|
373 |
int i = 0;
|
|
374 |
for (i = 0; i < num_threads; i++) {
|
|
375 |
jlong tid = ids_ah->long_at(i);
|
|
376 |
if (tid <= 0) {
|
|
377 |
// throw exception if invalid thread id.
|
|
378 |
THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
|
|
379 |
"Invalid thread ID entry");
|
|
380 |
}
|
|
381 |
}
|
|
382 |
|
|
383 |
}
|
|
384 |
|
|
385 |
static void validate_thread_info_array(objArrayHandle infoArray_h, TRAPS) {
|
|
386 |
|
|
387 |
// check if the element of infoArray is of type ThreadInfo class
|
|
388 |
klassOop threadinfo_klass = Management::java_lang_management_ThreadInfo_klass(CHECK);
|
|
389 |
klassOop element_klass = objArrayKlass::cast(infoArray_h->klass())->element_klass();
|
|
390 |
if (element_klass != threadinfo_klass) {
|
|
391 |
THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
|
|
392 |
"infoArray element type is not ThreadInfo class");
|
|
393 |
}
|
|
394 |
|
|
395 |
}
|
|
396 |
|
|
397 |
|
|
398 |
static MemoryManager* get_memory_manager_from_jobject(jobject obj, TRAPS) {
|
|
399 |
if (obj == NULL) {
|
|
400 |
THROW_(vmSymbols::java_lang_NullPointerException(), NULL);
|
|
401 |
}
|
|
402 |
|
|
403 |
oop mgr_obj = JNIHandles::resolve(obj);
|
|
404 |
assert(mgr_obj->is_instance(), "Should be an instanceOop");
|
|
405 |
instanceHandle mh(THREAD, (instanceOop) mgr_obj);
|
|
406 |
|
|
407 |
return MemoryService::get_memory_manager(mh);
|
|
408 |
}
|
|
409 |
|
|
410 |
// Returns a version string and sets major and minor version if
|
|
411 |
// the input parameters are non-null.
|
|
412 |
JVM_LEAF(jint, jmm_GetVersion(JNIEnv *env))
|
|
413 |
return JMM_VERSION;
|
|
414 |
JVM_END
|
|
415 |
|
|
416 |
// Gets the list of VM monitoring and management optional supports
|
|
417 |
// Returns 0 if succeeded; otherwise returns non-zero.
|
|
418 |
JVM_LEAF(jint, jmm_GetOptionalSupport(JNIEnv *env, jmmOptionalSupport* support))
|
|
419 |
if (support == NULL) {
|
|
420 |
return -1;
|
|
421 |
}
|
|
422 |
Management::get_optional_support(support);
|
|
423 |
return 0;
|
|
424 |
JVM_END
|
|
425 |
|
|
426 |
// Returns a java.lang.String object containing the input arguments to the VM.
|
|
427 |
JVM_ENTRY(jobject, jmm_GetInputArguments(JNIEnv *env))
|
|
428 |
ResourceMark rm(THREAD);
|
|
429 |
|
|
430 |
if (Arguments::num_jvm_args() == 0 && Arguments::num_jvm_flags() == 0) {
|
|
431 |
return NULL;
|
|
432 |
}
|
|
433 |
|
|
434 |
char** vm_flags = Arguments::jvm_flags_array();
|
|
435 |
char** vm_args = Arguments::jvm_args_array();
|
|
436 |
int num_flags = Arguments::num_jvm_flags();
|
|
437 |
int num_args = Arguments::num_jvm_args();
|
|
438 |
|
|
439 |
size_t length = 1; // null terminator
|
|
440 |
int i;
|
|
441 |
for (i = 0; i < num_flags; i++) {
|
|
442 |
length += strlen(vm_flags[i]);
|
|
443 |
}
|
|
444 |
for (i = 0; i < num_args; i++) {
|
|
445 |
length += strlen(vm_args[i]);
|
|
446 |
}
|
|
447 |
// add a space between each argument
|
|
448 |
length += num_flags + num_args - 1;
|
|
449 |
|
|
450 |
// Return the list of input arguments passed to the VM
|
|
451 |
// and preserve the order that the VM processes.
|
|
452 |
char* args = NEW_RESOURCE_ARRAY(char, length);
|
|
453 |
args[0] = '\0';
|
|
454 |
// concatenate all jvm_flags
|
|
455 |
if (num_flags > 0) {
|
|
456 |
strcat(args, vm_flags[0]);
|
|
457 |
for (i = 1; i < num_flags; i++) {
|
|
458 |
strcat(args, " ");
|
|
459 |
strcat(args, vm_flags[i]);
|
|
460 |
}
|
|
461 |
}
|
|
462 |
|
|
463 |
if (num_args > 0 && num_flags > 0) {
|
|
464 |
// append a space if args already contains one or more jvm_flags
|
|
465 |
strcat(args, " ");
|
|
466 |
}
|
|
467 |
|
|
468 |
// concatenate all jvm_args
|
|
469 |
if (num_args > 0) {
|
|
470 |
strcat(args, vm_args[0]);
|
|
471 |
for (i = 1; i < num_args; i++) {
|
|
472 |
strcat(args, " ");
|
|
473 |
strcat(args, vm_args[i]);
|
|
474 |
}
|
|
475 |
}
|
|
476 |
|
|
477 |
Handle hargs = java_lang_String::create_from_platform_dependent_str(args, CHECK_NULL);
|
|
478 |
return JNIHandles::make_local(env, hargs());
|
|
479 |
JVM_END
|
|
480 |
|
|
481 |
// Returns an array of java.lang.String object containing the input arguments to the VM.
|
|
482 |
JVM_ENTRY(jobjectArray, jmm_GetInputArgumentArray(JNIEnv *env))
|
|
483 |
ResourceMark rm(THREAD);
|
|
484 |
|
|
485 |
if (Arguments::num_jvm_args() == 0 && Arguments::num_jvm_flags() == 0) {
|
|
486 |
return NULL;
|
|
487 |
}
|
|
488 |
|
|
489 |
char** vm_flags = Arguments::jvm_flags_array();
|
|
490 |
char** vm_args = Arguments::jvm_args_array();
|
|
491 |
int num_flags = Arguments::num_jvm_flags();
|
|
492 |
int num_args = Arguments::num_jvm_args();
|
|
493 |
|
|
494 |
instanceKlassHandle ik (THREAD, SystemDictionary::string_klass());
|
|
495 |
objArrayOop r = oopFactory::new_objArray(ik(), num_args + num_flags, CHECK_NULL);
|
|
496 |
objArrayHandle result_h(THREAD, r);
|
|
497 |
|
|
498 |
int index = 0;
|
|
499 |
for (int j = 0; j < num_flags; j++, index++) {
|
|
500 |
Handle h = java_lang_String::create_from_platform_dependent_str(vm_flags[j], CHECK_NULL);
|
|
501 |
result_h->obj_at_put(index, h());
|
|
502 |
}
|
|
503 |
for (int i = 0; i < num_args; i++, index++) {
|
|
504 |
Handle h = java_lang_String::create_from_platform_dependent_str(vm_args[i], CHECK_NULL);
|
|
505 |
result_h->obj_at_put(index, h());
|
|
506 |
}
|
|
507 |
return (jobjectArray) JNIHandles::make_local(env, result_h());
|
|
508 |
JVM_END
|
|
509 |
|
|
510 |
// Returns an array of java/lang/management/MemoryPoolMXBean object
|
|
511 |
// one for each memory pool if obj == null; otherwise returns
|
|
512 |
// an array of memory pools for a given memory manager if
|
|
513 |
// it is a valid memory manager.
|
|
514 |
JVM_ENTRY(jobjectArray, jmm_GetMemoryPools(JNIEnv* env, jobject obj))
|
|
515 |
ResourceMark rm(THREAD);
|
|
516 |
|
|
517 |
int num_memory_pools;
|
|
518 |
MemoryManager* mgr = NULL;
|
|
519 |
if (obj == NULL) {
|
|
520 |
num_memory_pools = MemoryService::num_memory_pools();
|
|
521 |
} else {
|
|
522 |
mgr = get_memory_manager_from_jobject(obj, CHECK_NULL);
|
|
523 |
if (mgr == NULL) {
|
|
524 |
return NULL;
|
|
525 |
}
|
|
526 |
num_memory_pools = mgr->num_memory_pools();
|
|
527 |
}
|
|
528 |
|
|
529 |
// Allocate the resulting MemoryPoolMXBean[] object
|
|
530 |
klassOop k = Management::java_lang_management_MemoryPoolMXBean_klass(CHECK_NULL);
|
|
531 |
instanceKlassHandle ik (THREAD, k);
|
|
532 |
objArrayOop r = oopFactory::new_objArray(ik(), num_memory_pools, CHECK_NULL);
|
|
533 |
objArrayHandle poolArray(THREAD, r);
|
|
534 |
|
|
535 |
if (mgr == NULL) {
|
|
536 |
// Get all memory pools
|
|
537 |
for (int i = 0; i < num_memory_pools; i++) {
|
|
538 |
MemoryPool* pool = MemoryService::get_memory_pool(i);
|
|
539 |
instanceOop p = pool->get_memory_pool_instance(CHECK_NULL);
|
|
540 |
instanceHandle ph(THREAD, p);
|
|
541 |
poolArray->obj_at_put(i, ph());
|
|
542 |
}
|
|
543 |
} else {
|
|
544 |
// Get memory pools managed by a given memory manager
|
|
545 |
for (int i = 0; i < num_memory_pools; i++) {
|
|
546 |
MemoryPool* pool = mgr->get_memory_pool(i);
|
|
547 |
instanceOop p = pool->get_memory_pool_instance(CHECK_NULL);
|
|
548 |
instanceHandle ph(THREAD, p);
|
|
549 |
poolArray->obj_at_put(i, ph());
|
|
550 |
}
|
|
551 |
}
|
|
552 |
return (jobjectArray) JNIHandles::make_local(env, poolArray());
|
|
553 |
JVM_END
|
|
554 |
|
|
555 |
// Returns an array of java/lang/management/MemoryManagerMXBean object
|
|
556 |
// one for each memory manager if obj == null; otherwise returns
|
|
557 |
// an array of memory managers for a given memory pool if
|
|
558 |
// it is a valid memory pool.
|
|
559 |
JVM_ENTRY(jobjectArray, jmm_GetMemoryManagers(JNIEnv* env, jobject obj))
|
|
560 |
ResourceMark rm(THREAD);
|
|
561 |
|
|
562 |
int num_mgrs;
|
|
563 |
MemoryPool* pool = NULL;
|
|
564 |
if (obj == NULL) {
|
|
565 |
num_mgrs = MemoryService::num_memory_managers();
|
|
566 |
} else {
|
|
567 |
pool = get_memory_pool_from_jobject(obj, CHECK_NULL);
|
|
568 |
if (pool == NULL) {
|
|
569 |
return NULL;
|
|
570 |
}
|
|
571 |
num_mgrs = pool->num_memory_managers();
|
|
572 |
}
|
|
573 |
|
|
574 |
// Allocate the resulting MemoryManagerMXBean[] object
|
|
575 |
klassOop k = Management::java_lang_management_MemoryManagerMXBean_klass(CHECK_NULL);
|
|
576 |
instanceKlassHandle ik (THREAD, k);
|
|
577 |
objArrayOop r = oopFactory::new_objArray(ik(), num_mgrs, CHECK_NULL);
|
|
578 |
objArrayHandle mgrArray(THREAD, r);
|
|
579 |
|
|
580 |
if (pool == NULL) {
|
|
581 |
// Get all memory managers
|
|
582 |
for (int i = 0; i < num_mgrs; i++) {
|
|
583 |
MemoryManager* mgr = MemoryService::get_memory_manager(i);
|
|
584 |
instanceOop p = mgr->get_memory_manager_instance(CHECK_NULL);
|
|
585 |
instanceHandle ph(THREAD, p);
|
|
586 |
mgrArray->obj_at_put(i, ph());
|
|
587 |
}
|
|
588 |
} else {
|
|
589 |
// Get memory managers for a given memory pool
|
|
590 |
for (int i = 0; i < num_mgrs; i++) {
|
|
591 |
MemoryManager* mgr = pool->get_memory_manager(i);
|
|
592 |
instanceOop p = mgr->get_memory_manager_instance(CHECK_NULL);
|
|
593 |
instanceHandle ph(THREAD, p);
|
|
594 |
mgrArray->obj_at_put(i, ph());
|
|
595 |
}
|
|
596 |
}
|
|
597 |
return (jobjectArray) JNIHandles::make_local(env, mgrArray());
|
|
598 |
JVM_END
|
|
599 |
|
|
600 |
|
|
601 |
// Returns a java/lang/management/MemoryUsage object containing the memory usage
|
|
602 |
// of a given memory pool.
|
|
603 |
JVM_ENTRY(jobject, jmm_GetMemoryPoolUsage(JNIEnv* env, jobject obj))
|
|
604 |
ResourceMark rm(THREAD);
|
|
605 |
|
|
606 |
MemoryPool* pool = get_memory_pool_from_jobject(obj, CHECK_NULL);
|
|
607 |
if (pool != NULL) {
|
|
608 |
MemoryUsage usage = pool->get_memory_usage();
|
|
609 |
Handle h = MemoryService::create_MemoryUsage_obj(usage, CHECK_NULL);
|
|
610 |
return JNIHandles::make_local(env, h());
|
|
611 |
} else {
|
|
612 |
return NULL;
|
|
613 |
}
|
|
614 |
JVM_END
|
|
615 |
|
|
616 |
// Returns a java/lang/management/MemoryUsage object containing the memory usage
|
|
617 |
// of a given memory pool.
|
|
618 |
JVM_ENTRY(jobject, jmm_GetPeakMemoryPoolUsage(JNIEnv* env, jobject obj))
|
|
619 |
ResourceMark rm(THREAD);
|
|
620 |
|
|
621 |
MemoryPool* pool = get_memory_pool_from_jobject(obj, CHECK_NULL);
|
|
622 |
if (pool != NULL) {
|
|
623 |
MemoryUsage usage = pool->get_peak_memory_usage();
|
|
624 |
Handle h = MemoryService::create_MemoryUsage_obj(usage, CHECK_NULL);
|
|
625 |
return JNIHandles::make_local(env, h());
|
|
626 |
} else {
|
|
627 |
return NULL;
|
|
628 |
}
|
|
629 |
JVM_END
|
|
630 |
|
|
631 |
// Returns a java/lang/management/MemoryUsage object containing the memory usage
|
|
632 |
// of a given memory pool after most recent GC.
|
|
633 |
JVM_ENTRY(jobject, jmm_GetPoolCollectionUsage(JNIEnv* env, jobject obj))
|
|
634 |
ResourceMark rm(THREAD);
|
|
635 |
|
|
636 |
MemoryPool* pool = get_memory_pool_from_jobject(obj, CHECK_NULL);
|
|
637 |
if (pool != NULL && pool->is_collected_pool()) {
|
|
638 |
MemoryUsage usage = pool->get_last_collection_usage();
|
|
639 |
Handle h = MemoryService::create_MemoryUsage_obj(usage, CHECK_NULL);
|
|
640 |
return JNIHandles::make_local(env, h());
|
|
641 |
} else {
|
|
642 |
return NULL;
|
|
643 |
}
|
|
644 |
JVM_END
|
|
645 |
|
|
646 |
// Sets the memory pool sensor for a threshold type
|
|
647 |
JVM_ENTRY(void, jmm_SetPoolSensor(JNIEnv* env, jobject obj, jmmThresholdType type, jobject sensorObj))
|
|
648 |
if (obj == NULL || sensorObj == NULL) {
|
|
649 |
THROW(vmSymbols::java_lang_NullPointerException());
|
|
650 |
}
|
|
651 |
|
|
652 |
klassOop sensor_klass = Management::sun_management_Sensor_klass(CHECK);
|
|
653 |
oop s = JNIHandles::resolve(sensorObj);
|
|
654 |
assert(s->is_instance(), "Sensor should be an instanceOop");
|
|
655 |
instanceHandle sensor_h(THREAD, (instanceOop) s);
|
|
656 |
if (!sensor_h->is_a(sensor_klass)) {
|
|
657 |
THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
|
|
658 |
"Sensor is not an instance of sun.management.Sensor class");
|
|
659 |
}
|
|
660 |
|
|
661 |
MemoryPool* mpool = get_memory_pool_from_jobject(obj, CHECK);
|
|
662 |
assert(mpool != NULL, "MemoryPool should exist");
|
|
663 |
|
|
664 |
switch (type) {
|
|
665 |
case JMM_USAGE_THRESHOLD_HIGH:
|
|
666 |
case JMM_USAGE_THRESHOLD_LOW:
|
|
667 |
// have only one sensor for threshold high and low
|
|
668 |
mpool->set_usage_sensor_obj(sensor_h);
|
|
669 |
break;
|
|
670 |
case JMM_COLLECTION_USAGE_THRESHOLD_HIGH:
|
|
671 |
case JMM_COLLECTION_USAGE_THRESHOLD_LOW:
|
|
672 |
// have only one sensor for threshold high and low
|
|
673 |
mpool->set_gc_usage_sensor_obj(sensor_h);
|
|
674 |
break;
|
|
675 |
default:
|
|
676 |
assert(false, "Unrecognized type");
|
|
677 |
}
|
|
678 |
|
|
679 |
JVM_END
|
|
680 |
|
|
681 |
|
|
682 |
// Sets the threshold of a given memory pool.
|
|
683 |
// Returns the previous threshold.
|
|
684 |
//
|
|
685 |
// Input parameters:
|
|
686 |
// pool - the MemoryPoolMXBean object
|
|
687 |
// type - threshold type
|
|
688 |
// threshold - the new threshold (must not be negative)
|
|
689 |
//
|
|
690 |
JVM_ENTRY(jlong, jmm_SetPoolThreshold(JNIEnv* env, jobject obj, jmmThresholdType type, jlong threshold))
|
|
691 |
if (threshold < 0) {
|
|
692 |
THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
|
|
693 |
"Invalid threshold value",
|
|
694 |
-1);
|
|
695 |
}
|
|
696 |
|
|
697 |
if (threshold > max_intx) {
|
|
698 |
THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
|
|
699 |
"Invalid threshold value > max value of size_t",
|
|
700 |
-1);
|
|
701 |
}
|
|
702 |
|
|
703 |
MemoryPool* pool = get_memory_pool_from_jobject(obj, CHECK_(0L));
|
|
704 |
assert(pool != NULL, "MemoryPool should exist");
|
|
705 |
|
|
706 |
jlong prev = 0;
|
|
707 |
switch (type) {
|
|
708 |
case JMM_USAGE_THRESHOLD_HIGH:
|
|
709 |
if (!pool->usage_threshold()->is_high_threshold_supported()) {
|
|
710 |
return -1;
|
|
711 |
}
|
|
712 |
prev = pool->usage_threshold()->set_high_threshold((size_t) threshold);
|
|
713 |
break;
|
|
714 |
|
|
715 |
case JMM_USAGE_THRESHOLD_LOW:
|
|
716 |
if (!pool->usage_threshold()->is_low_threshold_supported()) {
|
|
717 |
return -1;
|
|
718 |
}
|
|
719 |
prev = pool->usage_threshold()->set_low_threshold((size_t) threshold);
|
|
720 |
break;
|
|
721 |
|
|
722 |
case JMM_COLLECTION_USAGE_THRESHOLD_HIGH:
|
|
723 |
if (!pool->gc_usage_threshold()->is_high_threshold_supported()) {
|
|
724 |
return -1;
|
|
725 |
}
|
|
726 |
// return and the new threshold is effective for the next GC
|
|
727 |
return pool->gc_usage_threshold()->set_high_threshold((size_t) threshold);
|
|
728 |
|
|
729 |
case JMM_COLLECTION_USAGE_THRESHOLD_LOW:
|
|
730 |
if (!pool->gc_usage_threshold()->is_low_threshold_supported()) {
|
|
731 |
return -1;
|
|
732 |
}
|
|
733 |
// return and the new threshold is effective for the next GC
|
|
734 |
return pool->gc_usage_threshold()->set_low_threshold((size_t) threshold);
|
|
735 |
|
|
736 |
default:
|
|
737 |
assert(false, "Unrecognized type");
|
|
738 |
return -1;
|
|
739 |
}
|
|
740 |
|
|
741 |
// When the threshold is changed, reevaluate if the low memory
|
|
742 |
// detection is enabled.
|
|
743 |
if (prev != threshold) {
|
|
744 |
LowMemoryDetector::recompute_enabled_for_collected_pools();
|
|
745 |
LowMemoryDetector::detect_low_memory(pool);
|
|
746 |
}
|
|
747 |
return prev;
|
|
748 |
JVM_END
|
|
749 |
|
|
750 |
// Returns a java/lang/management/MemoryUsage object representing
|
|
751 |
// the memory usage for the heap or non-heap memory.
|
|
752 |
JVM_ENTRY(jobject, jmm_GetMemoryUsage(JNIEnv* env, jboolean heap))
|
|
753 |
ResourceMark rm(THREAD);
|
|
754 |
|
|
755 |
// Calculate the memory usage
|
|
756 |
size_t total_init = 0;
|
|
757 |
size_t total_used = 0;
|
|
758 |
size_t total_committed = 0;
|
|
759 |
size_t total_max = 0;
|
|
760 |
bool has_undefined_init_size = false;
|
|
761 |
bool has_undefined_max_size = false;
|
|
762 |
|
|
763 |
for (int i = 0; i < MemoryService::num_memory_pools(); i++) {
|
|
764 |
MemoryPool* pool = MemoryService::get_memory_pool(i);
|
|
765 |
if ((heap && pool->is_heap()) || (!heap && pool->is_non_heap())) {
|
|
766 |
MemoryUsage u = pool->get_memory_usage();
|
|
767 |
total_used += u.used();
|
|
768 |
total_committed += u.committed();
|
|
769 |
|
|
770 |
// if any one of the memory pool has undefined init_size or max_size,
|
|
771 |
// set it to -1
|
|
772 |
if (u.init_size() == (size_t)-1) {
|
|
773 |
has_undefined_init_size = true;
|
|
774 |
}
|
|
775 |
if (!has_undefined_init_size) {
|
|
776 |
total_init += u.init_size();
|
|
777 |
}
|
|
778 |
|
|
779 |
if (u.max_size() == (size_t)-1) {
|
|
780 |
has_undefined_max_size = true;
|
|
781 |
}
|
|
782 |
if (!has_undefined_max_size) {
|
|
783 |
total_max += u.max_size();
|
|
784 |
}
|
|
785 |
}
|
|
786 |
}
|
|
787 |
|
|
788 |
// In our current implementation, all pools should have
|
|
789 |
// defined init and max size
|
|
790 |
assert(!has_undefined_init_size, "Undefined init size");
|
|
791 |
assert(!has_undefined_max_size, "Undefined max size");
|
|
792 |
|
|
793 |
MemoryUsage usage((heap ? Arguments::initial_heap_size() : total_init),
|
|
794 |
total_used,
|
|
795 |
total_committed,
|
|
796 |
(heap ? Universe::heap()->max_capacity() : total_max));
|
|
797 |
|
|
798 |
Handle obj = MemoryService::create_MemoryUsage_obj(usage, CHECK_NULL);
|
|
799 |
return JNIHandles::make_local(env, obj());
|
|
800 |
JVM_END
|
|
801 |
|
|
802 |
// Returns the boolean value of a given attribute.
|
|
803 |
JVM_LEAF(jboolean, jmm_GetBoolAttribute(JNIEnv *env, jmmBoolAttribute att))
|
|
804 |
switch (att) {
|
|
805 |
case JMM_VERBOSE_GC:
|
|
806 |
return MemoryService::get_verbose();
|
|
807 |
case JMM_VERBOSE_CLASS:
|
|
808 |
return ClassLoadingService::get_verbose();
|
|
809 |
case JMM_THREAD_CONTENTION_MONITORING:
|
|
810 |
return ThreadService::is_thread_monitoring_contention();
|
|
811 |
case JMM_THREAD_CPU_TIME:
|
|
812 |
return ThreadService::is_thread_cpu_time_enabled();
|
|
813 |
default:
|
|
814 |
assert(0, "Unrecognized attribute");
|
|
815 |
return false;
|
|
816 |
}
|
|
817 |
JVM_END
|
|
818 |
|
|
819 |
// Sets the given boolean attribute and returns the previous value.
|
|
820 |
JVM_ENTRY(jboolean, jmm_SetBoolAttribute(JNIEnv *env, jmmBoolAttribute att, jboolean flag))
|
|
821 |
switch (att) {
|
|
822 |
case JMM_VERBOSE_GC:
|
|
823 |
return MemoryService::set_verbose(flag != 0);
|
|
824 |
case JMM_VERBOSE_CLASS:
|
|
825 |
return ClassLoadingService::set_verbose(flag != 0);
|
|
826 |
case JMM_THREAD_CONTENTION_MONITORING:
|
|
827 |
return ThreadService::set_thread_monitoring_contention(flag != 0);
|
|
828 |
case JMM_THREAD_CPU_TIME:
|
|
829 |
return ThreadService::set_thread_cpu_time_enabled(flag != 0);
|
|
830 |
default:
|
|
831 |
assert(0, "Unrecognized attribute");
|
|
832 |
return false;
|
|
833 |
}
|
|
834 |
JVM_END
|
|
835 |
|
|
836 |
|
|
837 |
static jlong get_gc_attribute(GCMemoryManager* mgr, jmmLongAttribute att) {
|
|
838 |
switch (att) {
|
|
839 |
case JMM_GC_TIME_MS:
|
|
840 |
return mgr->gc_time_ms();
|
|
841 |
|
|
842 |
case JMM_GC_COUNT:
|
|
843 |
return mgr->gc_count();
|
|
844 |
|
|
845 |
case JMM_GC_EXT_ATTRIBUTE_INFO_SIZE:
|
|
846 |
// current implementation only has 1 ext attribute
|
|
847 |
return 1;
|
|
848 |
|
|
849 |
default:
|
|
850 |
assert(0, "Unrecognized GC attribute");
|
|
851 |
return -1;
|
|
852 |
}
|
|
853 |
}
|
|
854 |
|
|
855 |
class VmThreadCountClosure: public ThreadClosure {
|
|
856 |
private:
|
|
857 |
int _count;
|
|
858 |
public:
|
|
859 |
VmThreadCountClosure() : _count(0) {};
|
|
860 |
void do_thread(Thread* thread);
|
|
861 |
int count() { return _count; }
|
|
862 |
};
|
|
863 |
|
|
864 |
void VmThreadCountClosure::do_thread(Thread* thread) {
|
|
865 |
// exclude externally visible JavaThreads
|
|
866 |
if (thread->is_Java_thread() && !thread->is_hidden_from_external_view()) {
|
|
867 |
return;
|
|
868 |
}
|
|
869 |
|
|
870 |
_count++;
|
|
871 |
}
|
|
872 |
|
|
873 |
static jint get_vm_thread_count() {
|
|
874 |
VmThreadCountClosure vmtcc;
|
|
875 |
{
|
|
876 |
MutexLockerEx ml(Threads_lock);
|
|
877 |
Threads::threads_do(&vmtcc);
|
|
878 |
}
|
|
879 |
|
|
880 |
return vmtcc.count();
|
|
881 |
}
|
|
882 |
|
|
883 |
static jint get_num_flags() {
|
|
884 |
// last flag entry is always NULL, so subtract 1
|
|
885 |
int nFlags = (int) Flag::numFlags - 1;
|
|
886 |
int count = 0;
|
|
887 |
for (int i = 0; i < nFlags; i++) {
|
|
888 |
Flag* flag = &Flag::flags[i];
|
|
889 |
// Exclude the diagnostic flags
|
|
890 |
if (flag->is_unlocked() || flag->is_unlocker()) {
|
|
891 |
count++;
|
|
892 |
}
|
|
893 |
}
|
|
894 |
return count;
|
|
895 |
}
|
|
896 |
|
|
897 |
static jlong get_long_attribute(jmmLongAttribute att) {
|
|
898 |
switch (att) {
|
|
899 |
case JMM_CLASS_LOADED_COUNT:
|
|
900 |
return ClassLoadingService::loaded_class_count();
|
|
901 |
|
|
902 |
case JMM_CLASS_UNLOADED_COUNT:
|
|
903 |
return ClassLoadingService::unloaded_class_count();
|
|
904 |
|
|
905 |
case JMM_THREAD_TOTAL_COUNT:
|
|
906 |
return ThreadService::get_total_thread_count();
|
|
907 |
|
|
908 |
case JMM_THREAD_LIVE_COUNT:
|
|
909 |
return ThreadService::get_live_thread_count();
|
|
910 |
|
|
911 |
case JMM_THREAD_PEAK_COUNT:
|
|
912 |
return ThreadService::get_peak_thread_count();
|
|
913 |
|
|
914 |
case JMM_THREAD_DAEMON_COUNT:
|
|
915 |
return ThreadService::get_daemon_thread_count();
|
|
916 |
|
|
917 |
case JMM_JVM_INIT_DONE_TIME_MS:
|
|
918 |
return Management::vm_init_done_time();
|
|
919 |
|
|
920 |
case JMM_COMPILE_TOTAL_TIME_MS:
|
|
921 |
return Management::ticks_to_ms(CompileBroker::total_compilation_ticks());
|
|
922 |
|
|
923 |
case JMM_OS_PROCESS_ID:
|
|
924 |
return os::current_process_id();
|
|
925 |
|
|
926 |
// Hotspot-specific counters
|
|
927 |
case JMM_CLASS_LOADED_BYTES:
|
|
928 |
return ClassLoadingService::loaded_class_bytes();
|
|
929 |
|
|
930 |
case JMM_CLASS_UNLOADED_BYTES:
|
|
931 |
return ClassLoadingService::unloaded_class_bytes();
|
|
932 |
|
|
933 |
case JMM_SHARED_CLASS_LOADED_COUNT:
|
|
934 |
return ClassLoadingService::loaded_shared_class_count();
|
|
935 |
|
|
936 |
case JMM_SHARED_CLASS_UNLOADED_COUNT:
|
|
937 |
return ClassLoadingService::unloaded_shared_class_count();
|
|
938 |
|
|
939 |
|
|
940 |
case JMM_SHARED_CLASS_LOADED_BYTES:
|
|
941 |
return ClassLoadingService::loaded_shared_class_bytes();
|
|
942 |
|
|
943 |
case JMM_SHARED_CLASS_UNLOADED_BYTES:
|
|
944 |
return ClassLoadingService::unloaded_shared_class_bytes();
|
|
945 |
|
|
946 |
case JMM_TOTAL_CLASSLOAD_TIME_MS:
|
|
947 |
return ClassLoader::classloader_time_ms();
|
|
948 |
|
|
949 |
case JMM_VM_GLOBAL_COUNT:
|
|
950 |
return get_num_flags();
|
|
951 |
|
|
952 |
case JMM_SAFEPOINT_COUNT:
|
|
953 |
return RuntimeService::safepoint_count();
|
|
954 |
|
|
955 |
case JMM_TOTAL_SAFEPOINTSYNC_TIME_MS:
|
|
956 |
return RuntimeService::safepoint_sync_time_ms();
|
|
957 |
|
|
958 |
case JMM_TOTAL_STOPPED_TIME_MS:
|
|
959 |
return RuntimeService::safepoint_time_ms();
|
|
960 |
|
|
961 |
case JMM_TOTAL_APP_TIME_MS:
|
|
962 |
return RuntimeService::application_time_ms();
|
|
963 |
|
|
964 |
case JMM_VM_THREAD_COUNT:
|
|
965 |
return get_vm_thread_count();
|
|
966 |
|
|
967 |
case JMM_CLASS_INIT_TOTAL_COUNT:
|
|
968 |
return ClassLoader::class_init_count();
|
|
969 |
|
|
970 |
case JMM_CLASS_INIT_TOTAL_TIME_MS:
|
|
971 |
return ClassLoader::class_init_time_ms();
|
|
972 |
|
|
973 |
case JMM_CLASS_VERIFY_TOTAL_TIME_MS:
|
|
974 |
return ClassLoader::class_verify_time_ms();
|
|
975 |
|
|
976 |
case JMM_METHOD_DATA_SIZE_BYTES:
|
|
977 |
return ClassLoadingService::class_method_data_size();
|
|
978 |
|
|
979 |
case JMM_OS_MEM_TOTAL_PHYSICAL_BYTES:
|
|
980 |
return os::physical_memory();
|
|
981 |
|
|
982 |
default:
|
|
983 |
return -1;
|
|
984 |
}
|
|
985 |
}
|
|
986 |
|
|
987 |
|
|
988 |
// Returns the long value of a given attribute.
|
|
989 |
JVM_ENTRY(jlong, jmm_GetLongAttribute(JNIEnv *env, jobject obj, jmmLongAttribute att))
|
|
990 |
if (obj == NULL) {
|
|
991 |
return get_long_attribute(att);
|
|
992 |
} else {
|
|
993 |
GCMemoryManager* mgr = get_gc_memory_manager_from_jobject(obj, CHECK_(0L));
|
|
994 |
if (mgr != NULL) {
|
|
995 |
return get_gc_attribute(mgr, att);
|
|
996 |
}
|
|
997 |
}
|
|
998 |
return -1;
|
|
999 |
JVM_END
|
|
1000 |
|
|
1001 |
// Gets the value of all attributes specified in the given array
|
|
1002 |
// and sets the value in the result array.
|
|
1003 |
// Returns the number of attributes found.
|
|
1004 |
JVM_ENTRY(jint, jmm_GetLongAttributes(JNIEnv *env,
|
|
1005 |
jobject obj,
|
|
1006 |
jmmLongAttribute* atts,
|
|
1007 |
jint count,
|
|
1008 |
jlong* result))
|
|
1009 |
|
|
1010 |
int num_atts = 0;
|
|
1011 |
if (obj == NULL) {
|
|
1012 |
for (int i = 0; i < count; i++) {
|
|
1013 |
result[i] = get_long_attribute(atts[i]);
|
|
1014 |
if (result[i] != -1) {
|
|
1015 |
num_atts++;
|
|
1016 |
}
|
|
1017 |
}
|
|
1018 |
} else {
|
|
1019 |
GCMemoryManager* mgr = get_gc_memory_manager_from_jobject(obj, CHECK_0);
|
|
1020 |
for (int i = 0; i < count; i++) {
|
|
1021 |
result[i] = get_gc_attribute(mgr, atts[i]);
|
|
1022 |
if (result[i] != -1) {
|
|
1023 |
num_atts++;
|
|
1024 |
}
|
|
1025 |
}
|
|
1026 |
}
|
|
1027 |
return num_atts;
|
|
1028 |
JVM_END
|
|
1029 |
|
|
1030 |
// Helper function to do thread dump for a specific list of threads
|
|
1031 |
static void do_thread_dump(ThreadDumpResult* dump_result,
|
|
1032 |
typeArrayHandle ids_ah, // array of thread ID (long[])
|
|
1033 |
int num_threads,
|
|
1034 |
int max_depth,
|
|
1035 |
bool with_locked_monitors,
|
|
1036 |
bool with_locked_synchronizers,
|
|
1037 |
TRAPS) {
|
|
1038 |
|
|
1039 |
// First get an array of threadObj handles.
|
|
1040 |
// A JavaThread may terminate before we get the stack trace.
|
|
1041 |
GrowableArray<instanceHandle>* thread_handle_array = new GrowableArray<instanceHandle>(num_threads);
|
|
1042 |
{
|
|
1043 |
MutexLockerEx ml(Threads_lock);
|
|
1044 |
for (int i = 0; i < num_threads; i++) {
|
|
1045 |
jlong tid = ids_ah->long_at(i);
|
|
1046 |
JavaThread* jt = find_java_thread_from_id(tid);
|
|
1047 |
oop thread_obj = (jt != NULL ? jt->threadObj() : (oop)NULL);
|
|
1048 |
instanceHandle threadObj_h(THREAD, (instanceOop) thread_obj);
|
|
1049 |
thread_handle_array->append(threadObj_h);
|
|
1050 |
}
|
|
1051 |
}
|
|
1052 |
|
|
1053 |
// Obtain thread dumps and thread snapshot information
|
|
1054 |
VM_ThreadDump op(dump_result,
|
|
1055 |
thread_handle_array,
|
|
1056 |
num_threads,
|
|
1057 |
max_depth, /* stack depth */
|
|
1058 |
with_locked_monitors,
|
|
1059 |
with_locked_synchronizers);
|
|
1060 |
VMThread::execute(&op);
|
|
1061 |
}
|
|
1062 |
|
|
1063 |
// Gets an array of ThreadInfo objects. Each element is the ThreadInfo
|
|
1064 |
// for the thread ID specified in the corresponding entry in
|
|
1065 |
// the given array of thread IDs; or NULL if the thread does not exist
|
|
1066 |
// or has terminated.
|
|
1067 |
//
|
|
1068 |
// Input parameters:
|
|
1069 |
// ids - array of thread IDs
|
|
1070 |
// maxDepth - the maximum depth of stack traces to be dumped:
|
|
1071 |
// maxDepth == -1 requests to dump entire stack trace.
|
|
1072 |
// maxDepth == 0 requests no stack trace.
|
|
1073 |
// infoArray - array of ThreadInfo objects
|
|
1074 |
//
|
|
1075 |
JVM_ENTRY(jint, jmm_GetThreadInfo(JNIEnv *env, jlongArray ids, jint maxDepth, jobjectArray infoArray))
|
|
1076 |
// Check if threads is null
|
|
1077 |
if (ids == NULL || infoArray == NULL) {
|
|
1078 |
THROW_(vmSymbols::java_lang_NullPointerException(), -1);
|
|
1079 |
}
|
|
1080 |
|
|
1081 |
if (maxDepth < -1) {
|
|
1082 |
THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
|
|
1083 |
"Invalid maxDepth", -1);
|
|
1084 |
}
|
|
1085 |
|
|
1086 |
ResourceMark rm(THREAD);
|
|
1087 |
typeArrayOop ta = typeArrayOop(JNIHandles::resolve_non_null(ids));
|
|
1088 |
typeArrayHandle ids_ah(THREAD, ta);
|
|
1089 |
|
|
1090 |
oop infoArray_obj = JNIHandles::resolve_non_null(infoArray);
|
|
1091 |
objArrayOop oa = objArrayOop(infoArray_obj);
|
|
1092 |
objArrayHandle infoArray_h(THREAD, oa);
|
|
1093 |
|
|
1094 |
// validate the thread id array
|
|
1095 |
validate_thread_id_array(ids_ah, CHECK_0);
|
|
1096 |
|
|
1097 |
// validate the ThreadInfo[] parameters
|
|
1098 |
validate_thread_info_array(infoArray_h, CHECK_0);
|
|
1099 |
|
|
1100 |
// infoArray must be of the same length as the given array of thread IDs
|
|
1101 |
int num_threads = ids_ah->length();
|
|
1102 |
if (num_threads != infoArray_h->length()) {
|
|
1103 |
THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
|
|
1104 |
"The length of the given ThreadInfo array does not match the length of the given array of thread IDs", -1);
|
|
1105 |
}
|
|
1106 |
|
|
1107 |
if (JDK_Version::is_gte_jdk16x_version()) {
|
|
1108 |
// make sure the AbstractOwnableSynchronizer klass is loaded before taking thread snapshots
|
|
1109 |
java_util_concurrent_locks_AbstractOwnableSynchronizer::initialize(CHECK_0);
|
|
1110 |
}
|
|
1111 |
|
|
1112 |
// Must use ThreadDumpResult to store the ThreadSnapshot.
|
|
1113 |
// GC may occur after the thread snapshots are taken but before
|
|
1114 |
// this function returns. The threadObj and other oops kept
|
|
1115 |
// in the ThreadSnapshot are marked and adjusted during GC.
|
|
1116 |
ThreadDumpResult dump_result(num_threads);
|
|
1117 |
|
|
1118 |
if (maxDepth == 0) {
|
|
1119 |
// no stack trace dumped - do not need to stop the world
|
|
1120 |
{
|
|
1121 |
MutexLockerEx ml(Threads_lock);
|
|
1122 |
for (int i = 0; i < num_threads; i++) {
|
|
1123 |
jlong tid = ids_ah->long_at(i);
|
|
1124 |
JavaThread* jt = find_java_thread_from_id(tid);
|
|
1125 |
ThreadSnapshot* ts;
|
|
1126 |
if (jt == NULL) {
|
|
1127 |
// if the thread does not exist or now it is terminated,
|
|
1128 |
// create dummy snapshot
|
|
1129 |
ts = new ThreadSnapshot();
|
|
1130 |
} else {
|
|
1131 |
ts = new ThreadSnapshot(jt);
|
|
1132 |
}
|
|
1133 |
dump_result.add_thread_snapshot(ts);
|
|
1134 |
}
|
|
1135 |
}
|
|
1136 |
} else {
|
|
1137 |
// obtain thread dump with the specific list of threads with stack trace
|
|
1138 |
|
|
1139 |
do_thread_dump(&dump_result,
|
|
1140 |
ids_ah,
|
|
1141 |
num_threads,
|
|
1142 |
maxDepth,
|
|
1143 |
false, /* no locked monitor */
|
|
1144 |
false, /* no locked synchronizers */
|
|
1145 |
CHECK_0);
|
|
1146 |
}
|
|
1147 |
|
|
1148 |
int num_snapshots = dump_result.num_snapshots();
|
|
1149 |
assert(num_snapshots == num_threads, "Must match the number of thread snapshots");
|
|
1150 |
int index = 0;
|
|
1151 |
for (ThreadSnapshot* ts = dump_result.snapshots(); ts != NULL; index++, ts = ts->next()) {
|
|
1152 |
// For each thread, create an java/lang/management/ThreadInfo object
|
|
1153 |
// and fill with the thread information
|
|
1154 |
|
|
1155 |
if (ts->threadObj() == NULL) {
|
|
1156 |
// if the thread does not exist or now it is terminated, set threadinfo to NULL
|
|
1157 |
infoArray_h->obj_at_put(index, NULL);
|
|
1158 |
continue;
|
|
1159 |
}
|
|
1160 |
|
|
1161 |
// Create java.lang.management.ThreadInfo object
|
|
1162 |
instanceOop info_obj = Management::create_thread_info_instance(ts, CHECK_0);
|
|
1163 |
infoArray_h->obj_at_put(index, info_obj);
|
|
1164 |
}
|
|
1165 |
return 0;
|
|
1166 |
JVM_END
|
|
1167 |
|
|
1168 |
// Dump thread info for the specified threads.
|
|
1169 |
// It returns an array of ThreadInfo objects. Each element is the ThreadInfo
|
|
1170 |
// for the thread ID specified in the corresponding entry in
|
|
1171 |
// the given array of thread IDs; or NULL if the thread does not exist
|
|
1172 |
// or has terminated.
|
|
1173 |
//
|
|
1174 |
// Input parameter:
|
|
1175 |
// ids - array of thread IDs; NULL indicates all live threads
|
|
1176 |
// locked_monitors - if true, dump locked object monitors
|
|
1177 |
// locked_synchronizers - if true, dump locked JSR-166 synchronizers
|
|
1178 |
//
|
|
1179 |
JVM_ENTRY(jobjectArray, jmm_DumpThreads(JNIEnv *env, jlongArray thread_ids, jboolean locked_monitors, jboolean locked_synchronizers))
|
|
1180 |
ResourceMark rm(THREAD);
|
|
1181 |
|
|
1182 |
if (JDK_Version::is_gte_jdk16x_version()) {
|
|
1183 |
// make sure the AbstractOwnableSynchronizer klass is loaded before taking thread snapshots
|
|
1184 |
java_util_concurrent_locks_AbstractOwnableSynchronizer::initialize(CHECK_NULL);
|
|
1185 |
}
|
|
1186 |
|
|
1187 |
typeArrayOop ta = typeArrayOop(JNIHandles::resolve(thread_ids));
|
|
1188 |
int num_threads = (ta != NULL ? ta->length() : 0);
|
|
1189 |
typeArrayHandle ids_ah(THREAD, ta);
|
|
1190 |
|
|
1191 |
ThreadDumpResult dump_result(num_threads); // can safepoint
|
|
1192 |
|
|
1193 |
if (ids_ah() != NULL) {
|
|
1194 |
|
|
1195 |
// validate the thread id array
|
|
1196 |
validate_thread_id_array(ids_ah, CHECK_NULL);
|
|
1197 |
|
|
1198 |
// obtain thread dump of a specific list of threads
|
|
1199 |
do_thread_dump(&dump_result,
|
|
1200 |
ids_ah,
|
|
1201 |
num_threads,
|
|
1202 |
-1, /* entire stack */
|
|
1203 |
(locked_monitors ? true : false), /* with locked monitors */
|
|
1204 |
(locked_synchronizers ? true : false), /* with locked synchronizers */
|
|
1205 |
CHECK_NULL);
|
|
1206 |
} else {
|
|
1207 |
// obtain thread dump of all threads
|
|
1208 |
VM_ThreadDump op(&dump_result,
|
|
1209 |
-1, /* entire stack */
|
|
1210 |
(locked_monitors ? true : false), /* with locked monitors */
|
|
1211 |
(locked_synchronizers ? true : false) /* with locked synchronizers */);
|
|
1212 |
VMThread::execute(&op);
|
|
1213 |
}
|
|
1214 |
|
|
1215 |
int num_snapshots = dump_result.num_snapshots();
|
|
1216 |
|
|
1217 |
// create the result ThreadInfo[] object
|
|
1218 |
klassOop k = Management::java_lang_management_ThreadInfo_klass(CHECK_NULL);
|
|
1219 |
instanceKlassHandle ik (THREAD, k);
|
|
1220 |
objArrayOop r = oopFactory::new_objArray(ik(), num_snapshots, CHECK_NULL);
|
|
1221 |
objArrayHandle result_h(THREAD, r);
|
|
1222 |
|
|
1223 |
int index = 0;
|
|
1224 |
for (ThreadSnapshot* ts = dump_result.snapshots(); ts != NULL; ts = ts->next(), index++) {
|
|
1225 |
if (ts->threadObj() == NULL) {
|
|
1226 |
// if the thread does not exist or now it is terminated, set threadinfo to NULL
|
|
1227 |
result_h->obj_at_put(index, NULL);
|
|
1228 |
continue;
|
|
1229 |
}
|
|
1230 |
|
|
1231 |
|
|
1232 |
|
|
1233 |
ThreadStackTrace* stacktrace = ts->get_stack_trace();
|
|
1234 |
assert(stacktrace != NULL, "Must have a stack trace dumped");
|
|
1235 |
|
|
1236 |
// Create Object[] filled with locked monitors
|
|
1237 |
// Create int[] filled with the stack depth where a monitor was locked
|
|
1238 |
int num_frames = stacktrace->get_stack_depth();
|
|
1239 |
int num_locked_monitors = stacktrace->num_jni_locked_monitors();
|
|
1240 |
|
|
1241 |
// Count the total number of locked monitors
|
|
1242 |
for (int i = 0; i < num_frames; i++) {
|
|
1243 |
StackFrameInfo* frame = stacktrace->stack_frame_at(i);
|
|
1244 |
num_locked_monitors += frame->num_locked_monitors();
|
|
1245 |
}
|
|
1246 |
|
|
1247 |
objArrayHandle monitors_array;
|
|
1248 |
typeArrayHandle depths_array;
|
|
1249 |
objArrayHandle synchronizers_array;
|
|
1250 |
|
|
1251 |
if (locked_monitors) {
|
|
1252 |
// Constructs Object[] and int[] to contain the object monitor and the stack depth
|
|
1253 |
// where the thread locked it
|
|
1254 |
objArrayOop array = oopFactory::new_system_objArray(num_locked_monitors, CHECK_NULL);
|
|
1255 |
objArrayHandle mh(THREAD, array);
|
|
1256 |
monitors_array = mh;
|
|
1257 |
|
|
1258 |
typeArrayOop tarray = oopFactory::new_typeArray(T_INT, num_locked_monitors, CHECK_NULL);
|
|
1259 |
typeArrayHandle dh(THREAD, tarray);
|
|
1260 |
depths_array = dh;
|
|
1261 |
|
|
1262 |
int count = 0;
|
|
1263 |
int j = 0;
|
|
1264 |
for (int depth = 0; depth < num_frames; depth++) {
|
|
1265 |
StackFrameInfo* frame = stacktrace->stack_frame_at(depth);
|
|
1266 |
int len = frame->num_locked_monitors();
|
|
1267 |
GrowableArray<oop>* locked_monitors = frame->locked_monitors();
|
|
1268 |
for (j = 0; j < len; j++) {
|
|
1269 |
oop monitor = locked_monitors->at(j);
|
|
1270 |
assert(monitor != NULL && monitor->is_instance(), "must be a Java object");
|
|
1271 |
monitors_array->obj_at_put(count, monitor);
|
|
1272 |
depths_array->int_at_put(count, depth);
|
|
1273 |
count++;
|
|
1274 |
}
|
|
1275 |
}
|
|
1276 |
|
|
1277 |
GrowableArray<oop>* jni_locked_monitors = stacktrace->jni_locked_monitors();
|
|
1278 |
for (j = 0; j < jni_locked_monitors->length(); j++) {
|
|
1279 |
oop object = jni_locked_monitors->at(j);
|
|
1280 |
assert(object != NULL && object->is_instance(), "must be a Java object");
|
|
1281 |
monitors_array->obj_at_put(count, object);
|
|
1282 |
// Monitor locked via JNI MonitorEnter call doesn't have stack depth info
|
|
1283 |
depths_array->int_at_put(count, -1);
|
|
1284 |
count++;
|
|
1285 |
}
|
|
1286 |
assert(count == num_locked_monitors, "number of locked monitors doesn't match");
|
|
1287 |
}
|
|
1288 |
|
|
1289 |
if (locked_synchronizers) {
|
|
1290 |
// Create Object[] filled with locked JSR-166 synchronizers
|
|
1291 |
assert(ts->threadObj() != NULL, "Must be a valid JavaThread");
|
|
1292 |
ThreadConcurrentLocks* tcl = ts->get_concurrent_locks();
|
|
1293 |
GrowableArray<instanceOop>* locks = (tcl != NULL ? tcl->owned_locks() : NULL);
|
|
1294 |
int num_locked_synchronizers = (locks != NULL ? locks->length() : 0);
|
|
1295 |
|
|
1296 |
objArrayOop array = oopFactory::new_system_objArray(num_locked_synchronizers, CHECK_NULL);
|
|
1297 |
objArrayHandle sh(THREAD, array);
|
|
1298 |
synchronizers_array = sh;
|
|
1299 |
|
|
1300 |
for (int k = 0; k < num_locked_synchronizers; k++) {
|
|
1301 |
synchronizers_array->obj_at_put(k, locks->at(k));
|
|
1302 |
}
|
|
1303 |
}
|
|
1304 |
|
|
1305 |
// Create java.lang.management.ThreadInfo object
|
|
1306 |
instanceOop info_obj = Management::create_thread_info_instance(ts,
|
|
1307 |
monitors_array,
|
|
1308 |
depths_array,
|
|
1309 |
synchronizers_array,
|
|
1310 |
CHECK_NULL);
|
|
1311 |
result_h->obj_at_put(index, info_obj);
|
|
1312 |
}
|
|
1313 |
|
|
1314 |
return (jobjectArray) JNIHandles::make_local(env, result_h());
|
|
1315 |
JVM_END
|
|
1316 |
|
|
1317 |
// Returns an array of Class objects.
|
|
1318 |
JVM_ENTRY(jobjectArray, jmm_GetLoadedClasses(JNIEnv *env))
|
|
1319 |
ResourceMark rm(THREAD);
|
|
1320 |
|
|
1321 |
LoadedClassesEnumerator lce(THREAD); // Pass current Thread as parameter
|
|
1322 |
|
|
1323 |
int num_classes = lce.num_loaded_classes();
|
|
1324 |
objArrayOop r = oopFactory::new_objArray(SystemDictionary::class_klass(), num_classes, CHECK_0);
|
|
1325 |
objArrayHandle classes_ah(THREAD, r);
|
|
1326 |
|
|
1327 |
for (int i = 0; i < num_classes; i++) {
|
|
1328 |
KlassHandle kh = lce.get_klass(i);
|
|
1329 |
oop mirror = Klass::cast(kh())->java_mirror();
|
|
1330 |
classes_ah->obj_at_put(i, mirror);
|
|
1331 |
}
|
|
1332 |
|
|
1333 |
return (jobjectArray) JNIHandles::make_local(env, classes_ah());
|
|
1334 |
JVM_END
|
|
1335 |
|
|
1336 |
// Reset statistic. Return true if the requested statistic is reset.
|
|
1337 |
// Otherwise, return false.
|
|
1338 |
//
|
|
1339 |
// Input parameters:
|
|
1340 |
// obj - specify which instance the statistic associated with to be reset
|
|
1341 |
// For PEAK_POOL_USAGE stat, obj is required to be a memory pool object.
|
|
1342 |
// For THREAD_CONTENTION_COUNT and TIME stat, obj is required to be a thread ID.
|
|
1343 |
// type - the type of statistic to be reset
|
|
1344 |
//
|
|
1345 |
JVM_ENTRY(jboolean, jmm_ResetStatistic(JNIEnv *env, jvalue obj, jmmStatisticType type))
|
|
1346 |
ResourceMark rm(THREAD);
|
|
1347 |
|
|
1348 |
switch (type) {
|
|
1349 |
case JMM_STAT_PEAK_THREAD_COUNT:
|
|
1350 |
ThreadService::reset_peak_thread_count();
|
|
1351 |
return true;
|
|
1352 |
|
|
1353 |
case JMM_STAT_THREAD_CONTENTION_COUNT:
|
|
1354 |
case JMM_STAT_THREAD_CONTENTION_TIME: {
|
|
1355 |
jlong tid = obj.j;
|
|
1356 |
if (tid < 0) {
|
|
1357 |
THROW_(vmSymbols::java_lang_IllegalArgumentException(), JNI_FALSE);
|
|
1358 |
}
|
|
1359 |
|
|
1360 |
// Look for the JavaThread of this given tid
|
|
1361 |
MutexLockerEx ml(Threads_lock);
|
|
1362 |
if (tid == 0) {
|
|
1363 |
// reset contention statistics for all threads if tid == 0
|
|
1364 |
for (JavaThread* java_thread = Threads::first(); java_thread != NULL; java_thread = java_thread->next()) {
|
|
1365 |
if (type == JMM_STAT_THREAD_CONTENTION_COUNT) {
|
|
1366 |
ThreadService::reset_contention_count_stat(java_thread);
|
|
1367 |
} else {
|
|
1368 |
ThreadService::reset_contention_time_stat(java_thread);
|
|
1369 |
}
|
|
1370 |
}
|
|
1371 |
} else {
|
|
1372 |
// reset contention statistics for a given thread
|
|
1373 |
JavaThread* java_thread = find_java_thread_from_id(tid);
|
|
1374 |
if (java_thread == NULL) {
|
|
1375 |
return false;
|
|
1376 |
}
|
|
1377 |
|
|
1378 |
if (type == JMM_STAT_THREAD_CONTENTION_COUNT) {
|
|
1379 |
ThreadService::reset_contention_count_stat(java_thread);
|
|
1380 |
} else {
|
|
1381 |
ThreadService::reset_contention_time_stat(java_thread);
|
|
1382 |
}
|
|
1383 |
}
|
|
1384 |
return true;
|
|
1385 |
break;
|
|
1386 |
}
|
|
1387 |
case JMM_STAT_PEAK_POOL_USAGE: {
|
|
1388 |
jobject o = obj.l;
|
|
1389 |
if (o == NULL) {
|
|
1390 |
THROW_(vmSymbols::java_lang_NullPointerException(), JNI_FALSE);
|
|
1391 |
}
|
|
1392 |
|
|
1393 |
oop pool_obj = JNIHandles::resolve(o);
|
|
1394 |
assert(pool_obj->is_instance(), "Should be an instanceOop");
|
|
1395 |
instanceHandle ph(THREAD, (instanceOop) pool_obj);
|
|
1396 |
|
|
1397 |
MemoryPool* pool = MemoryService::get_memory_pool(ph);
|
|
1398 |
if (pool != NULL) {
|
|
1399 |
pool->reset_peak_memory_usage();
|
|
1400 |
return true;
|
|
1401 |
}
|
|
1402 |
break;
|
|
1403 |
}
|
|
1404 |
case JMM_STAT_GC_STAT: {
|
|
1405 |
jobject o = obj.l;
|
|
1406 |
if (o == NULL) {
|
|
1407 |
THROW_(vmSymbols::java_lang_NullPointerException(), JNI_FALSE);
|
|
1408 |
}
|
|
1409 |
|
|
1410 |
GCMemoryManager* mgr = get_gc_memory_manager_from_jobject(o, CHECK_0);
|
|
1411 |
if (mgr != NULL) {
|
|
1412 |
mgr->reset_gc_stat();
|
|
1413 |
return true;
|
|
1414 |
}
|
|
1415 |
break;
|
|
1416 |
}
|
|
1417 |
default:
|
|
1418 |
assert(0, "Unknown Statistic Type");
|
|
1419 |
}
|
|
1420 |
return false;
|
|
1421 |
JVM_END
|
|
1422 |
|
|
1423 |
// Returns the fast estimate of CPU time consumed by
|
|
1424 |
// a given thread (in nanoseconds).
|
|
1425 |
// If thread_id == 0, return CPU time for the current thread.
|
|
1426 |
JVM_ENTRY(jlong, jmm_GetThreadCpuTime(JNIEnv *env, jlong thread_id))
|
|
1427 |
if (!os::is_thread_cpu_time_supported()) {
|
|
1428 |
return -1;
|
|
1429 |
}
|
|
1430 |
|
|
1431 |
if (thread_id < 0) {
|
|
1432 |
THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
|
|
1433 |
"Invalid thread ID", -1);
|
|
1434 |
}
|
|
1435 |
|
|
1436 |
JavaThread* java_thread = NULL;
|
|
1437 |
if (thread_id == 0) {
|
|
1438 |
// current thread
|
|
1439 |
return os::current_thread_cpu_time();
|
|
1440 |
} else {
|
|
1441 |
MutexLockerEx ml(Threads_lock);
|
|
1442 |
java_thread = find_java_thread_from_id(thread_id);
|
|
1443 |
if (java_thread != NULL) {
|
|
1444 |
return os::thread_cpu_time((Thread*) java_thread);
|
|
1445 |
}
|
|
1446 |
}
|
|
1447 |
return -1;
|
|
1448 |
JVM_END
|
|
1449 |
|
|
1450 |
// Returns the CPU time consumed by a given thread (in nanoseconds).
|
|
1451 |
// If thread_id == 0, CPU time for the current thread is returned.
|
|
1452 |
// If user_sys_cpu_time = true, user level and system CPU time of
|
|
1453 |
// a given thread is returned; otherwise, only user level CPU time
|
|
1454 |
// is returned.
|
|
1455 |
JVM_ENTRY(jlong, jmm_GetThreadCpuTimeWithKind(JNIEnv *env, jlong thread_id, jboolean user_sys_cpu_time))
|
|
1456 |
if (!os::is_thread_cpu_time_supported()) {
|
|
1457 |
return -1;
|
|
1458 |
}
|
|
1459 |
|
|
1460 |
if (thread_id < 0) {
|
|
1461 |
THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
|
|
1462 |
"Invalid thread ID", -1);
|
|
1463 |
}
|
|
1464 |
|
|
1465 |
JavaThread* java_thread = NULL;
|
|
1466 |
if (thread_id == 0) {
|
|
1467 |
// current thread
|
|
1468 |
return os::current_thread_cpu_time(user_sys_cpu_time != 0);
|
|
1469 |
} else {
|
|
1470 |
MutexLockerEx ml(Threads_lock);
|
|
1471 |
java_thread = find_java_thread_from_id(thread_id);
|
|
1472 |
if (java_thread != NULL) {
|
|
1473 |
return os::thread_cpu_time((Thread*) java_thread, user_sys_cpu_time != 0);
|
|
1474 |
}
|
|
1475 |
}
|
|
1476 |
return -1;
|
|
1477 |
JVM_END
|
|
1478 |
|
|
1479 |
// Returns a String array of all VM global flag names
|
|
1480 |
JVM_ENTRY(jobjectArray, jmm_GetVMGlobalNames(JNIEnv *env))
|
|
1481 |
// last flag entry is always NULL, so subtract 1
|
|
1482 |
int nFlags = (int) Flag::numFlags - 1;
|
|
1483 |
// allocate a temp array
|
|
1484 |
objArrayOop r = oopFactory::new_objArray(SystemDictionary::string_klass(),
|
|
1485 |
nFlags, CHECK_0);
|
|
1486 |
objArrayHandle flags_ah(THREAD, r);
|
|
1487 |
int num_entries = 0;
|
|
1488 |
for (int i = 0; i < nFlags; i++) {
|
|
1489 |
Flag* flag = &Flag::flags[i];
|
|
1490 |
// Exclude the diagnostic flags
|
|
1491 |
if (flag->is_unlocked() || flag->is_unlocker()) {
|
|
1492 |
Handle s = java_lang_String::create_from_str(flag->name, CHECK_0);
|
|
1493 |
flags_ah->obj_at_put(num_entries, s());
|
|
1494 |
num_entries++;
|
|
1495 |
}
|
|
1496 |
}
|
|
1497 |
|
|
1498 |
if (num_entries < nFlags) {
|
|
1499 |
// Return array of right length
|
|
1500 |
objArrayOop res = oopFactory::new_objArray(SystemDictionary::string_klass(), num_entries, CHECK_0);
|
|
1501 |
for(int i = 0; i < num_entries; i++) {
|
|
1502 |
res->obj_at_put(i, flags_ah->obj_at(i));
|
|
1503 |
}
|
|
1504 |
return (jobjectArray)JNIHandles::make_local(env, res);
|
|
1505 |
}
|
|
1506 |
|
|
1507 |
return (jobjectArray)JNIHandles::make_local(env, flags_ah());
|
|
1508 |
JVM_END
|
|
1509 |
|
|
1510 |
// utility function used by jmm_GetVMGlobals
|
|
1511 |
void add_global_entry(JNIEnv* env, Handle name, jmmVMGlobal *global, Flag *flag, TRAPS) {
|
|
1512 |
Handle flag_name;
|
|
1513 |
if (name() == NULL) {
|
|
1514 |
flag_name = java_lang_String::create_from_str(flag->name, CHECK);
|
|
1515 |
} else {
|
|
1516 |
flag_name = name;
|
|
1517 |
}
|
|
1518 |
global->name = (jstring)JNIHandles::make_local(env, flag_name());
|
|
1519 |
global->type = JMM_VMGLOBAL_TYPE_UNKNOWN;
|
|
1520 |
|
|
1521 |
if (flag->is_bool()) {
|
|
1522 |
global->value.z = flag->get_bool() ? JNI_TRUE : JNI_FALSE;
|
|
1523 |
global->type = JMM_VMGLOBAL_TYPE_JBOOLEAN;
|
|
1524 |
} else if (flag->is_intx()) {
|
|
1525 |
global->value.j = (jlong)flag->get_intx();
|
|
1526 |
global->type = JMM_VMGLOBAL_TYPE_JLONG;
|
|
1527 |
} else if (flag->is_uintx()) {
|
|
1528 |
global->value.j = (jlong)flag->get_uintx();
|
|
1529 |
global->type = JMM_VMGLOBAL_TYPE_JLONG;
|
|
1530 |
} else if (flag->is_ccstr()) {
|
|
1531 |
Handle str = java_lang_String::create_from_str(flag->get_ccstr(), CHECK);
|
|
1532 |
global->value.l = (jobject)JNIHandles::make_local(env, str());
|
|
1533 |
global->type = JMM_VMGLOBAL_TYPE_JSTRING;
|
|
1534 |
}
|
|
1535 |
|
|
1536 |
global->writeable = flag->is_writeable();
|
|
1537 |
global->external = flag->is_external();
|
|
1538 |
switch (flag->origin) {
|
|
1539 |
case DEFAULT:
|
|
1540 |
global->origin = JMM_VMGLOBAL_ORIGIN_DEFAULT;
|
|
1541 |
break;
|
|
1542 |
case COMMAND_LINE:
|
|
1543 |
global->origin = JMM_VMGLOBAL_ORIGIN_COMMAND_LINE;
|
|
1544 |
break;
|
|
1545 |
case ENVIRON_VAR:
|
|
1546 |
global->origin = JMM_VMGLOBAL_ORIGIN_ENVIRON_VAR;
|
|
1547 |
break;
|
|
1548 |
case CONFIG_FILE:
|
|
1549 |
global->origin = JMM_VMGLOBAL_ORIGIN_CONFIG_FILE;
|
|
1550 |
break;
|
|
1551 |
case MANAGEMENT:
|
|
1552 |
global->origin = JMM_VMGLOBAL_ORIGIN_MANAGEMENT;
|
|
1553 |
break;
|
|
1554 |
case ERGONOMIC:
|
|
1555 |
global->origin = JMM_VMGLOBAL_ORIGIN_ERGONOMIC;
|
|
1556 |
break;
|
|
1557 |
default:
|
|
1558 |
global->origin = JMM_VMGLOBAL_ORIGIN_OTHER;
|
|
1559 |
}
|
|
1560 |
}
|
|
1561 |
|
|
1562 |
// Fill globals array of count length with jmmVMGlobal entries
|
|
1563 |
// specified by names. If names == NULL, fill globals array
|
|
1564 |
// with all Flags. Return value is number of entries
|
|
1565 |
// created in globals.
|
|
1566 |
// If a Flag with a given name in an array element does not
|
|
1567 |
// exist, globals[i].name will be set to NULL.
|
|
1568 |
JVM_ENTRY(jint, jmm_GetVMGlobals(JNIEnv *env,
|
|
1569 |
jobjectArray names,
|
|
1570 |
jmmVMGlobal *globals,
|
|
1571 |
jint count))
|
|
1572 |
|
|
1573 |
|
|
1574 |
if (globals == NULL) {
|
|
1575 |
THROW_(vmSymbols::java_lang_NullPointerException(), 0);
|
|
1576 |
}
|
|
1577 |
|
|
1578 |
ResourceMark rm(THREAD);
|
|
1579 |
|
|
1580 |
if (names != NULL) {
|
|
1581 |
// return the requested globals
|
|
1582 |
objArrayOop ta = objArrayOop(JNIHandles::resolve_non_null(names));
|
|
1583 |
objArrayHandle names_ah(THREAD, ta);
|
|
1584 |
// Make sure we have a String array
|
|
1585 |
klassOop element_klass = objArrayKlass::cast(names_ah->klass())->element_klass();
|
|
1586 |
if (element_klass != SystemDictionary::string_klass()) {
|
|
1587 |
THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
|
|
1588 |
"Array element type is not String class", 0);
|
|
1589 |
}
|
|
1590 |
|
|
1591 |
int names_length = names_ah->length();
|
|
1592 |
int num_entries = 0;
|
|
1593 |
for (int i = 0; i < names_length && i < count; i++) {
|
|
1594 |
oop s = names_ah->obj_at(i);
|
|
1595 |
if (s == NULL) {
|
|
1596 |
THROW_(vmSymbols::java_lang_NullPointerException(), 0);
|
|
1597 |
}
|
|
1598 |
|
|
1599 |
Handle sh(THREAD, s);
|
|
1600 |
char* str = java_lang_String::as_utf8_string(s);
|
|
1601 |
Flag* flag = Flag::find_flag(str, strlen(str));
|
|
1602 |
if (flag != NULL) {
|
|
1603 |
add_global_entry(env, sh, &globals[i], flag, THREAD);
|
|
1604 |
num_entries++;
|
|
1605 |
} else {
|
|
1606 |
globals[i].name = NULL;
|
|
1607 |
}
|
|
1608 |
}
|
|
1609 |
return num_entries;
|
|
1610 |
} else {
|
|
1611 |
// return all globals if names == NULL
|
|
1612 |
|
|
1613 |
// last flag entry is always NULL, so subtract 1
|
|
1614 |
int nFlags = (int) Flag::numFlags - 1;
|
|
1615 |
Handle null_h;
|
|
1616 |
int num_entries = 0;
|
|
1617 |
for (int i = 0; i < nFlags && num_entries < count; i++) {
|
|
1618 |
Flag* flag = &Flag::flags[i];
|
|
1619 |
// Exclude the diagnostic flags
|
|
1620 |
if (flag->is_unlocked() || flag->is_unlocker()) {
|
|
1621 |
add_global_entry(env, null_h, &globals[num_entries], flag, THREAD);
|
|
1622 |
num_entries++;
|
|
1623 |
}
|
|
1624 |
}
|
|
1625 |
return num_entries;
|
|
1626 |
}
|
|
1627 |
JVM_END
|
|
1628 |
|
|
1629 |
JVM_ENTRY(void, jmm_SetVMGlobal(JNIEnv *env, jstring flag_name, jvalue new_value))
|
|
1630 |
ResourceMark rm(THREAD);
|
|
1631 |
|
|
1632 |
oop fn = JNIHandles::resolve_external_guard(flag_name);
|
|
1633 |
if (fn == NULL) {
|
|
1634 |
THROW_MSG(vmSymbols::java_lang_NullPointerException(),
|
|
1635 |
"The flag name cannot be null.");
|
|
1636 |
}
|
|
1637 |
char* name = java_lang_String::as_utf8_string(fn);
|
|
1638 |
Flag* flag = Flag::find_flag(name, strlen(name));
|
|
1639 |
if (flag == NULL) {
|
|
1640 |
THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
|
|
1641 |
"Flag does not exist.");
|
|
1642 |
}
|
|
1643 |
if (!flag->is_writeable()) {
|
|
1644 |
THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
|
|
1645 |
"This flag is not writeable.");
|
|
1646 |
}
|
|
1647 |
|
|
1648 |
bool succeed;
|
|
1649 |
if (flag->is_bool()) {
|
|
1650 |
bool bvalue = (new_value.z == JNI_TRUE ? true : false);
|
|
1651 |
succeed = CommandLineFlags::boolAtPut(name, &bvalue, MANAGEMENT);
|
|
1652 |
} else if (flag->is_intx()) {
|
|
1653 |
intx ivalue = new_value.j;
|
|
1654 |
succeed = CommandLineFlags::intxAtPut(name, &ivalue, MANAGEMENT);
|
|
1655 |
} else if (flag->is_uintx()) {
|
|
1656 |
uintx uvalue = new_value.j;
|
|
1657 |
succeed = CommandLineFlags::uintxAtPut(name, &uvalue, MANAGEMENT);
|
|
1658 |
} else if (flag->is_ccstr()) {
|
|
1659 |
oop str = JNIHandles::resolve_external_guard(new_value.l);
|
|
1660 |
if (str == NULL) {
|
|
1661 |
THROW(vmSymbols::java_lang_NullPointerException());
|
|
1662 |
}
|
|
1663 |
ccstr svalue = java_lang_String::as_utf8_string(str);
|
|
1664 |
succeed = CommandLineFlags::ccstrAtPut(name, &svalue, MANAGEMENT);
|
|
1665 |
}
|
|
1666 |
assert(succeed, "Setting flag should succeed");
|
|
1667 |
JVM_END
|
|
1668 |
|
|
1669 |
class ThreadTimesClosure: public ThreadClosure {
|
|
1670 |
private:
|
|
1671 |
objArrayOop _names;
|
|
1672 |
typeArrayOop _times;
|
|
1673 |
int _names_len;
|
|
1674 |
int _times_len;
|
|
1675 |
int _count;
|
|
1676 |
|
|
1677 |
public:
|
|
1678 |
ThreadTimesClosure(objArrayOop names, typeArrayOop times);
|
|
1679 |
virtual void do_thread(Thread* thread);
|
|
1680 |
int count() { return _count; }
|
|
1681 |
};
|
|
1682 |
|
|
1683 |
ThreadTimesClosure::ThreadTimesClosure(objArrayOop names,
|
|
1684 |
typeArrayOop times) {
|
|
1685 |
assert(names != NULL, "names was NULL");
|
|
1686 |
assert(times != NULL, "times was NULL");
|
|
1687 |
_names = names;
|
|
1688 |
_names_len = names->length();
|
|
1689 |
_times = times;
|
|
1690 |
_times_len = times->length();
|
|
1691 |
_count = 0;
|
|
1692 |
}
|
|
1693 |
|
|
1694 |
void ThreadTimesClosure::do_thread(Thread* thread) {
|
|
1695 |
Handle s;
|
|
1696 |
assert(thread != NULL, "thread was NULL");
|
|
1697 |
|
|
1698 |
// exclude externally visible JavaThreads
|
|
1699 |
if (thread->is_Java_thread() && !thread->is_hidden_from_external_view()) {
|
|
1700 |
return;
|
|
1701 |
}
|
|
1702 |
|
|
1703 |
if (_count >= _names_len || _count >= _times_len) {
|
|
1704 |
// skip if the result array is not big enough
|
|
1705 |
return;
|
|
1706 |
}
|
|
1707 |
|
|
1708 |
EXCEPTION_MARK;
|
|
1709 |
|
|
1710 |
assert(thread->name() != NULL, "All threads should have a name");
|
|
1711 |
s = java_lang_String::create_from_str(thread->name(), CHECK);
|
|
1712 |
_names->obj_at_put(_count, s());
|
|
1713 |
|
|
1714 |
_times->long_at_put(_count, os::is_thread_cpu_time_supported() ?
|
|
1715 |
os::thread_cpu_time(thread) : -1);
|
|
1716 |
_count++;
|
|
1717 |
}
|
|
1718 |
|
|
1719 |
// Fills names with VM internal thread names and times with the corresponding
|
|
1720 |
// CPU times. If names or times is NULL, a NullPointerException is thrown.
|
|
1721 |
// If the element type of names is not String, an IllegalArgumentException is
|
|
1722 |
// thrown.
|
|
1723 |
// If an array is not large enough to hold all the entries, only the entries
|
|
1724 |
// that fit will be returned. Return value is the number of VM internal
|
|
1725 |
// threads entries.
|
|
1726 |
JVM_ENTRY(jint, jmm_GetInternalThreadTimes(JNIEnv *env,
|
|
1727 |
jobjectArray names,
|
|
1728 |
jlongArray times))
|
|
1729 |
if (names == NULL || times == NULL) {
|
|
1730 |
THROW_(vmSymbols::java_lang_NullPointerException(), 0);
|
|
1731 |
}
|
|
1732 |
objArrayOop na = objArrayOop(JNIHandles::resolve_non_null(names));
|
|
1733 |
objArrayHandle names_ah(THREAD, na);
|
|
1734 |
|
|
1735 |
// Make sure we have a String array
|
|
1736 |
klassOop element_klass = objArrayKlass::cast(names_ah->klass())->element_klass();
|
|
1737 |
if (element_klass != SystemDictionary::string_klass()) {
|
|
1738 |
THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
|
|
1739 |
"Array element type is not String class", 0);
|
|
1740 |
}
|
|
1741 |
|
|
1742 |
typeArrayOop ta = typeArrayOop(JNIHandles::resolve_non_null(times));
|
|
1743 |
typeArrayHandle times_ah(THREAD, ta);
|
|
1744 |
|
|
1745 |
ThreadTimesClosure ttc(names_ah(), times_ah());
|
|
1746 |
{
|
|
1747 |
MutexLockerEx ml(Threads_lock);
|
|
1748 |
Threads::threads_do(&ttc);
|
|
1749 |
}
|
|
1750 |
|
|
1751 |
return ttc.count();
|
|
1752 |
JVM_END
|
|
1753 |
|
|
1754 |
static Handle find_deadlocks(bool object_monitors_only, TRAPS) {
|
|
1755 |
ResourceMark rm(THREAD);
|
|
1756 |
|
|
1757 |
VM_FindDeadlocks op(!object_monitors_only /* also check concurrent locks? */);
|
|
1758 |
VMThread::execute(&op);
|
|
1759 |
|
|
1760 |
DeadlockCycle* deadlocks = op.result();
|
|
1761 |
if (deadlocks == NULL) {
|
|
1762 |
// no deadlock found and return
|
|
1763 |
return Handle();
|
|
1764 |
}
|
|
1765 |
|
|
1766 |
int num_threads = 0;
|
|
1767 |
DeadlockCycle* cycle;
|
|
1768 |
for (cycle = deadlocks; cycle != NULL; cycle = cycle->next()) {
|
|
1769 |
num_threads += cycle->num_threads();
|
|
1770 |
}
|
|
1771 |
|
|
1772 |
objArrayOop r = oopFactory::new_objArray(SystemDictionary::thread_klass(), num_threads, CHECK_NH);
|
|
1773 |
objArrayHandle threads_ah(THREAD, r);
|
|
1774 |
|
|
1775 |
int index = 0;
|
|
1776 |
for (cycle = deadlocks; cycle != NULL; cycle = cycle->next()) {
|
|
1777 |
GrowableArray<JavaThread*>* deadlock_threads = cycle->threads();
|
|
1778 |
int len = deadlock_threads->length();
|
|
1779 |
for (int i = 0; i < len; i++) {
|
|
1780 |
threads_ah->obj_at_put(index, deadlock_threads->at(i)->threadObj());
|
|
1781 |
index++;
|
|
1782 |
}
|
|
1783 |
}
|
|
1784 |
return threads_ah;
|
|
1785 |
}
|
|
1786 |
|
|
1787 |
// Finds cycles of threads that are deadlocked involved in object monitors
|
|
1788 |
// and JSR-166 synchronizers.
|
|
1789 |
// Returns an array of Thread objects which are in deadlock, if any.
|
|
1790 |
// Otherwise, returns NULL.
|
|
1791 |
//
|
|
1792 |
// Input parameter:
|
|
1793 |
// object_monitors_only - if true, only check object monitors
|
|
1794 |
//
|
|
1795 |
JVM_ENTRY(jobjectArray, jmm_FindDeadlockedThreads(JNIEnv *env, jboolean object_monitors_only))
|
|
1796 |
Handle result = find_deadlocks(object_monitors_only != 0, CHECK_0);
|
|
1797 |
return (jobjectArray) JNIHandles::make_local(env, result());
|
|
1798 |
JVM_END
|
|
1799 |
|
|
1800 |
// Finds cycles of threads that are deadlocked on monitor locks
|
|
1801 |
// Returns an array of Thread objects which are in deadlock, if any.
|
|
1802 |
// Otherwise, returns NULL.
|
|
1803 |
JVM_ENTRY(jobjectArray, jmm_FindMonitorDeadlockedThreads(JNIEnv *env))
|
|
1804 |
Handle result = find_deadlocks(true, CHECK_0);
|
|
1805 |
return (jobjectArray) JNIHandles::make_local(env, result());
|
|
1806 |
JVM_END
|
|
1807 |
|
|
1808 |
// Gets the information about GC extension attributes including
|
|
1809 |
// the name of the attribute, its type, and a short description.
|
|
1810 |
//
|
|
1811 |
// Input parameters:
|
|
1812 |
// mgr - GC memory manager
|
|
1813 |
// info - caller allocated array of jmmExtAttributeInfo
|
|
1814 |
// count - number of elements of the info array
|
|
1815 |
//
|
|
1816 |
// Returns the number of GC extension attributes filled in the info array; or
|
|
1817 |
// -1 if info is not big enough
|
|
1818 |
//
|
|
1819 |
JVM_ENTRY(jint, jmm_GetGCExtAttributeInfo(JNIEnv *env, jobject mgr, jmmExtAttributeInfo* info, jint count))
|
|
1820 |
// All GC memory managers have 1 attribute (number of GC threads)
|
|
1821 |
if (count == 0) {
|
|
1822 |
return 0;
|
|
1823 |
}
|
|
1824 |
|
|
1825 |
if (info == NULL) {
|
|
1826 |
THROW_(vmSymbols::java_lang_NullPointerException(), 0);
|
|
1827 |
}
|
|
1828 |
|
|
1829 |
info[0].name = "GcThreadCount";
|
|
1830 |
info[0].type = 'I';
|
|
1831 |
info[0].description = "Number of GC threads";
|
|
1832 |
return 1;
|
|
1833 |
JVM_END
|
|
1834 |
|
|
1835 |
// verify the given array is an array of java/lang/management/MemoryUsage objects
|
|
1836 |
// of a given length and return the objArrayOop
|
|
1837 |
static objArrayOop get_memory_usage_objArray(jobjectArray array, int length, TRAPS) {
|
|
1838 |
if (array == NULL) {
|
|
1839 |
THROW_(vmSymbols::java_lang_NullPointerException(), 0);
|
|
1840 |
}
|
|
1841 |
|
|
1842 |
objArrayOop oa = objArrayOop(JNIHandles::resolve_non_null(array));
|
|
1843 |
objArrayHandle array_h(THREAD, oa);
|
|
1844 |
|
|
1845 |
// array must be of the given length
|
|
1846 |
if (length != array_h->length()) {
|
|
1847 |
THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
|
|
1848 |
"The length of the given MemoryUsage array does not match the number of memory pools.", 0);
|
|
1849 |
}
|
|
1850 |
|
|
1851 |
// check if the element of array is of type MemoryUsage class
|
|
1852 |
klassOop usage_klass = Management::java_lang_management_MemoryUsage_klass(CHECK_0);
|
|
1853 |
klassOop element_klass = objArrayKlass::cast(array_h->klass())->element_klass();
|
|
1854 |
if (element_klass != usage_klass) {
|
|
1855 |
THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
|
|
1856 |
"The element type is not MemoryUsage class", 0);
|
|
1857 |
}
|
|
1858 |
|
|
1859 |
return array_h();
|
|
1860 |
}
|
|
1861 |
|
|
1862 |
// Gets the statistics of the last GC of a given GC memory manager.
|
|
1863 |
// Input parameters:
|
|
1864 |
// obj - GarbageCollectorMXBean object
|
|
1865 |
// gc_stat - caller allocated jmmGCStat where:
|
|
1866 |
// a. before_gc_usage - array of MemoryUsage objects
|
|
1867 |
// b. after_gc_usage - array of MemoryUsage objects
|
|
1868 |
// c. gc_ext_attributes_values_size is set to the
|
|
1869 |
// gc_ext_attribute_values array allocated
|
|
1870 |
// d. gc_ext_attribute_values is a caller allocated array of jvalue.
|
|
1871 |
//
|
|
1872 |
// On return,
|
|
1873 |
// gc_index == 0 indicates no GC statistics available
|
|
1874 |
//
|
|
1875 |
// before_gc_usage and after_gc_usage - filled with per memory pool
|
|
1876 |
// before and after GC usage in the same order as the memory pools
|
|
1877 |
// returned by GetMemoryPools for a given GC memory manager.
|
|
1878 |
// num_gc_ext_attributes indicates the number of elements in
|
|
1879 |
// the gc_ext_attribute_values array is filled; or
|
|
1880 |
// -1 if the gc_ext_attributes_values array is not big enough
|
|
1881 |
//
|
|
1882 |
JVM_ENTRY(void, jmm_GetLastGCStat(JNIEnv *env, jobject obj, jmmGCStat *gc_stat))
|
|
1883 |
ResourceMark rm(THREAD);
|
|
1884 |
|
|
1885 |
if (gc_stat->gc_ext_attribute_values_size > 0 && gc_stat->gc_ext_attribute_values == NULL) {
|
|
1886 |
THROW(vmSymbols::java_lang_NullPointerException());
|
|
1887 |
}
|
|
1888 |
|
|
1889 |
// Get the GCMemoryManager
|
|
1890 |
GCMemoryManager* mgr = get_gc_memory_manager_from_jobject(obj, CHECK);
|
|
1891 |
if (mgr->last_gc_stat() == NULL) {
|
|
1892 |
gc_stat->gc_index = 0;
|
|
1893 |
return;
|
|
1894 |
}
|
|
1895 |
|
|
1896 |
// Make a copy of the last GC statistics
|
|
1897 |
// GC may occur while constructing the last GC information
|
|
1898 |
int num_pools = MemoryService::num_memory_pools();
|
|
1899 |
GCStatInfo* stat = new GCStatInfo(num_pools);
|
|
1900 |
stat->copy_stat(mgr->last_gc_stat());
|
|
1901 |
|
|
1902 |
gc_stat->gc_index = stat->gc_index();
|
|
1903 |
gc_stat->start_time = Management::ticks_to_ms(stat->start_time());
|
|
1904 |
gc_stat->end_time = Management::ticks_to_ms(stat->end_time());
|
|
1905 |
|
|
1906 |
// Current implementation does not have GC extension attributes
|
|
1907 |
gc_stat->num_gc_ext_attributes = 0;
|
|
1908 |
|
|
1909 |
// Fill the arrays of MemoryUsage objects with before and after GC
|
|
1910 |
// per pool memory usage
|
|
1911 |
objArrayOop bu = get_memory_usage_objArray(gc_stat->usage_before_gc,
|
|
1912 |
num_pools,
|
|
1913 |
CHECK);
|
|
1914 |
objArrayHandle usage_before_gc_ah(THREAD, bu);
|
|
1915 |
|
|
1916 |
objArrayOop au = get_memory_usage_objArray(gc_stat->usage_after_gc,
|
|
1917 |
num_pools,
|
|
1918 |
CHECK);
|
|
1919 |
objArrayHandle usage_after_gc_ah(THREAD, au);
|
|
1920 |
|
|
1921 |
for (int i = 0; i < num_pools; i++) {
|
|
1922 |
Handle before_usage = MemoryService::create_MemoryUsage_obj(stat->before_gc_usage_for_pool(i), CHECK);
|
|
1923 |
Handle after_usage;
|
|
1924 |
|
|
1925 |
MemoryUsage u = stat->after_gc_usage_for_pool(i);
|
|
1926 |
if (u.max_size() == 0 && u.used() > 0) {
|
|
1927 |
// If max size == 0, this pool is a survivor space.
|
|
1928 |
// Set max size = -1 since the pools will be swapped after GC.
|
|
1929 |
MemoryUsage usage(u.init_size(), u.used(), u.committed(), (size_t)-1);
|
|
1930 |
after_usage = MemoryService::create_MemoryUsage_obj(usage, CHECK);
|
|
1931 |
} else {
|
|
1932 |
after_usage = MemoryService::create_MemoryUsage_obj(stat->after_gc_usage_for_pool(i), CHECK);
|
|
1933 |
}
|
|
1934 |
usage_before_gc_ah->obj_at_put(i, before_usage());
|
|
1935 |
usage_after_gc_ah->obj_at_put(i, after_usage());
|
|
1936 |
}
|
|
1937 |
|
|
1938 |
if (gc_stat->gc_ext_attribute_values_size > 0) {
|
|
1939 |
// Current implementation only has 1 attribute (number of GC threads)
|
|
1940 |
// The type is 'I'
|
|
1941 |
gc_stat->gc_ext_attribute_values[0].i = mgr->num_gc_threads();
|
|
1942 |
}
|
|
1943 |
JVM_END
|
|
1944 |
|
|
1945 |
// Dump heap - Returns 0 if succeeds.
|
|
1946 |
JVM_ENTRY(jint, jmm_DumpHeap0(JNIEnv *env, jstring outputfile, jboolean live))
|
|
1947 |
#ifndef SERVICES_KERNEL
|
|
1948 |
ResourceMark rm(THREAD);
|
|
1949 |
oop on = JNIHandles::resolve_external_guard(outputfile);
|
|
1950 |
if (on == NULL) {
|
|
1951 |
THROW_MSG_(vmSymbols::java_lang_NullPointerException(),
|
|
1952 |
"Output file name cannot be null.", -1);
|
|
1953 |
}
|
|
1954 |
char* name = java_lang_String::as_utf8_string(on);
|
|
1955 |
if (name == NULL) {
|
|
1956 |
THROW_MSG_(vmSymbols::java_lang_NullPointerException(),
|
|
1957 |
"Output file name cannot be null.", -1);
|
|
1958 |
}
|
|
1959 |
HeapDumper dumper(live ? true : false);
|
|
1960 |
if (dumper.dump(name) != 0) {
|
|
1961 |
const char* errmsg = dumper.error_as_C_string();
|
|
1962 |
THROW_MSG_(vmSymbols::java_io_IOException(), errmsg, -1);
|
|
1963 |
}
|
|
1964 |
return 0;
|
|
1965 |
#else // SERVICES_KERNEL
|
|
1966 |
return -1;
|
|
1967 |
#endif // SERVICES_KERNEL
|
|
1968 |
JVM_END
|
|
1969 |
|
|
1970 |
jlong Management::ticks_to_ms(jlong ticks) {
|
|
1971 |
assert(os::elapsed_frequency() > 0, "Must be non-zero");
|
|
1972 |
return (jlong)(((double)ticks / (double)os::elapsed_frequency())
|
|
1973 |
* (double)1000.0);
|
|
1974 |
}
|
|
1975 |
|
|
1976 |
const struct jmmInterface_1_ jmm_interface = {
|
|
1977 |
NULL,
|
|
1978 |
NULL,
|
|
1979 |
jmm_GetVersion,
|
|
1980 |
jmm_GetOptionalSupport,
|
|
1981 |
jmm_GetInputArguments,
|
|
1982 |
jmm_GetThreadInfo,
|
|
1983 |
jmm_GetInputArgumentArray,
|
|
1984 |
jmm_GetMemoryPools,
|
|
1985 |
jmm_GetMemoryManagers,
|
|
1986 |
jmm_GetMemoryPoolUsage,
|
|
1987 |
jmm_GetPeakMemoryPoolUsage,
|
|
1988 |
NULL,
|
|
1989 |
jmm_GetMemoryUsage,
|
|
1990 |
jmm_GetLongAttribute,
|
|
1991 |
jmm_GetBoolAttribute,
|
|
1992 |
jmm_SetBoolAttribute,
|
|
1993 |
jmm_GetLongAttributes,
|
|
1994 |
jmm_FindMonitorDeadlockedThreads,
|
|
1995 |
jmm_GetThreadCpuTime,
|
|
1996 |
jmm_GetVMGlobalNames,
|
|
1997 |
jmm_GetVMGlobals,
|
|
1998 |
jmm_GetInternalThreadTimes,
|
|
1999 |
jmm_ResetStatistic,
|
|
2000 |
jmm_SetPoolSensor,
|
|
2001 |
jmm_SetPoolThreshold,
|
|
2002 |
jmm_GetPoolCollectionUsage,
|
|
2003 |
jmm_GetGCExtAttributeInfo,
|
|
2004 |
jmm_GetLastGCStat,
|
|
2005 |
jmm_GetThreadCpuTimeWithKind,
|
|
2006 |
NULL,
|
|
2007 |
jmm_DumpHeap0,
|
|
2008 |
jmm_FindDeadlockedThreads,
|
|
2009 |
jmm_SetVMGlobal,
|
|
2010 |
NULL,
|
|
2011 |
jmm_DumpThreads
|
|
2012 |
};
|
|
2013 |
|
|
2014 |
void* Management::get_jmm_interface(int version) {
|
|
2015 |
if (version == JMM_VERSION_1_0) {
|
|
2016 |
return (void*) &jmm_interface;
|
|
2017 |
}
|
|
2018 |
return NULL;
|
|
2019 |
}
|