jdk-sandbox: comparison hotspot/src/share/vm/services/management.cpp

equal deleted inserted replaced

-:8fae37350972
+:a92d706dbdd5
 /*
-* Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 _optional_support.isOtherThreadCpuTimeSupported = 1;
 } else {
 _optional_support.isCurrentThreadCpuTimeSupported = 0;
 _optional_support.isOtherThreadCpuTimeSupported = 0;
 }
 _optional_support.isBootClassPathSupported = 1;
 _optional_support.isObjectMonitorUsageSupported = 1;
 #ifndef SERVICES_KERNEL
 // This depends on the heap inspector
 _optional_support.isSynchronizerUsageSupported = 1;
 #endif // SERVICES_KERNEL
+_optional_support.isThreadAllocatedMemorySupported = 1;
 }
 void Management::initialize(TRAPS) {
 // Start the low memory detector thread
 LowMemoryDetector::initialize();
 return MemoryService::get_memory_pool(ph);
 }
 static void validate_thread_id_array(typeArrayHandle ids_ah, TRAPS) {
 int num_threads = ids_ah->length();
-// should be non-empty array
-if (num_threads == 0) {
-THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
-"Empty array of thread IDs");
-}
 // Validate input thread IDs
 int i = 0;
 for (i = 0; i < num_threads; i++) {
 jlong tid = ids_ah->long_at(i);
 // throw exception if invalid thread id.
 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
 "Invalid thread ID entry");
 }
 }
 }
 static void validate_thread_info_array(objArrayHandle infoArray_h, TRAPS) {
 // check if the element of infoArray is of type ThreadInfo class
 klassOop threadinfo_klass = Management::java_lang_management_ThreadInfo_klass(CHECK);
 klassOop element_klass = objArrayKlass::cast(infoArray_h->klass())->element_klass();
 if (element_klass != threadinfo_klass) {
 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
 "infoArray element type is not ThreadInfo class");
 }
 }
 static MemoryManager* get_memory_manager_from_jobject(jobject obj, TRAPS) {
 if (obj == NULL) {
 LowMemoryDetector::detect_low_memory(pool);
 }
 return prev;
 JVM_END
+// Gets an array containing the amount of memory allocated on the Java
+// heap for a set of threads (in bytes).  Each element of the array is
+// the amount of memory allocated for the thread ID specified in the
+// corresponding entry in the given array of thread IDs; or -1 if the
+// thread does not exist or has terminated.
+JVM_ENTRY(void, jmm_GetThreadAllocatedMemory(JNIEnv *env, jlongArray ids,
+jlongArray sizeArray))
+// Check if threads is null
+if (ids == NULL || sizeArray == NULL) {
+THROW(vmSymbols::java_lang_NullPointerException());
+}
+ResourceMark rm(THREAD);
+typeArrayOop ta = typeArrayOop(JNIHandles::resolve_non_null(ids));
+typeArrayHandle ids_ah(THREAD, ta);
+typeArrayOop sa = typeArrayOop(JNIHandles::resolve_non_null(sizeArray));
+typeArrayHandle sizeArray_h(THREAD, sa);
+// validate the thread id array
+validate_thread_id_array(ids_ah, CHECK);
+// sizeArray must be of the same length as the given array of thread IDs
+int num_threads = ids_ah->length();
+if (num_threads != sizeArray_h->length()) {
+THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
+"The length of the given long array does not match the length of "
+"the given array of thread IDs");
+}
+MutexLockerEx ml(Threads_lock);
+for (int i = 0; i < num_threads; i++) {
+JavaThread* java_thread = find_java_thread_from_id(ids_ah->long_at(i));
+if (java_thread != NULL) {
+sizeArray_h->long_at_put(i, java_thread->cooked_allocated_bytes());
+}
+}
+JVM_END
 // Returns a java/lang/management/MemoryUsage object representing
 // the memory usage for the heap or non-heap memory.
 JVM_ENTRY(jobject, jmm_GetMemoryUsage(JNIEnv* env, jboolean heap))
 ResourceMark rm(THREAD);
 return ClassLoadingService::get_verbose();
 case JMM_THREAD_CONTENTION_MONITORING:
 return ThreadService::is_thread_monitoring_contention();
 case JMM_THREAD_CPU_TIME:
 return ThreadService::is_thread_cpu_time_enabled();
+case JMM_THREAD_ALLOCATED_MEMORY:
+return ThreadService::is_thread_allocated_memory_enabled();
 default:
 assert(0, "Unrecognized attribute");
 return false;
 }
 JVM_END
 return ClassLoadingService::set_verbose(flag != 0);
 case JMM_THREAD_CONTENTION_MONITORING:
 return ThreadService::set_thread_monitoring_contention(flag != 0);
 case JMM_THREAD_CPU_TIME:
 return ThreadService::set_thread_cpu_time_enabled(flag != 0);
+case JMM_THREAD_ALLOCATED_MEMORY:
+return ThreadService::set_thread_allocated_memory_enabled(flag != 0);
 default:
 assert(0, "Unrecognized attribute");
 return false;
 }
 JVM_END
 //   maxDepth  - the maximum depth of stack traces to be dumped:
 //               maxDepth == -1 requests to dump entire stack trace.
 //               maxDepth == 0  requests no stack trace.
 //   infoArray - array of ThreadInfo objects
 //
+// QQQ - Why does this method return a value instead of void?
 JVM_ENTRY(jint, jmm_GetThreadInfo(JNIEnv *env, jlongArray ids, jint maxDepth, jobjectArray infoArray))
 // Check if threads is null
 if (ids == NULL || infoArray == NULL) {
 THROW_(vmSymbols::java_lang_NullPointerException(), -1);
 }
 dump_result.add_thread_snapshot(ts);
 }
 }
 } else {
 // obtain thread dump with the specific list of threads with stack trace
 do_thread_dump(&dump_result,
 ids_ah,
 num_threads,
 maxDepth,
 false, /* no locked monitor */
 if (ts->threadObj() == NULL) {
 // if the thread does not exist or now it is terminated, set threadinfo to NULL
 result_h->obj_at_put(index, NULL);
 continue;
 }
 ThreadStackTrace* stacktrace = ts->get_stack_trace();
 assert(stacktrace != NULL, "Must have a stack trace dumped");
 // Create Object[] filled with locked monitors
 if (java_thread != NULL) {
 return os::thread_cpu_time((Thread*) java_thread, user_sys_cpu_time != 0);
 }
 }
 return -1;
+JVM_END
+// Gets an array containing the CPU times consumed by a set of threads
+// (in nanoseconds).  Each element of the array is the CPU time for the
+// thread ID specified in the corresponding entry in the given array
+// of thread IDs; or -1 if the thread does not exist or has terminated.
+// If user_sys_cpu_time = true, the sum of user level and system CPU time
+// for the given thread is returned; otherwise, only user level CPU time
+// is returned.
+JVM_ENTRY(void, jmm_GetThreadCpuTimesWithKind(JNIEnv *env, jlongArray ids,
+jlongArray timeArray,
+jboolean user_sys_cpu_time))
+// Check if threads is null
+if (ids == NULL || timeArray == NULL) {
+THROW(vmSymbols::java_lang_NullPointerException());
+}
+ResourceMark rm(THREAD);
+typeArrayOop ta = typeArrayOop(JNIHandles::resolve_non_null(ids));
+typeArrayHandle ids_ah(THREAD, ta);
+typeArrayOop tia = typeArrayOop(JNIHandles::resolve_non_null(timeArray));
+typeArrayHandle timeArray_h(THREAD, tia);
+// validate the thread id array
+validate_thread_id_array(ids_ah, CHECK);
+// timeArray must be of the same length as the given array of thread IDs
+int num_threads = ids_ah->length();
+if (num_threads != timeArray_h->length()) {
+THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
+"The length of the given long array does not match the length of "
+"the given array of thread IDs");
+}
+MutexLockerEx ml(Threads_lock);
+for (int i = 0; i < num_threads; i++) {
+JavaThread* java_thread = find_java_thread_from_id(ids_ah->long_at(i));
+if (java_thread != NULL) {
+timeArray_h->long_at_put(i, os::thread_cpu_time((Thread*)java_thread,
+user_sys_cpu_time != 0));
+}
+}
 JVM_END
 // Returns a String array of all VM global flag names
 JVM_ENTRY(jobjectArray, jmm_GetVMGlobalNames(JNIEnv *env))
 // last flag entry is always NULL, so subtract 1
 jmm_GetInputArgumentArray,
 jmm_GetMemoryPools,
 jmm_GetMemoryManagers,
 jmm_GetMemoryPoolUsage,
 jmm_GetPeakMemoryPoolUsage,
-NULL,
+jmm_GetThreadAllocatedMemory,
 jmm_GetMemoryUsage,
 jmm_GetLongAttribute,
 jmm_GetBoolAttribute,
 jmm_SetBoolAttribute,
 jmm_GetLongAttributes,
 jmm_SetPoolThreshold,
 jmm_GetPoolCollectionUsage,
 jmm_GetGCExtAttributeInfo,
 jmm_GetLastGCStat,
 jmm_GetThreadCpuTimeWithKind,
-NULL,
+jmm_GetThreadCpuTimesWithKind,
 jmm_DumpHeap0,
 jmm_FindDeadlockedThreads,
 jmm_SetVMGlobal,
 NULL,
 jmm_DumpThreads

changeset 7724	a92d706dbdd5
parent 7397	5b173b4ca846
child 8076	96d498ec7ae1