Mercurial > hg > truffle
comparison src/share/vm/services/gcNotifier.cpp @ 3356:78542e2b5e35
7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
Summary: Add a notification to the GarbageCollectorMXBeans
Reviewed-by: acorn, mchung
author | fparain |
---|---|
date | Thu, 12 May 2011 10:30:11 -0700 |
parents | |
children | 87e40b34bc2b |
comparison
equal
deleted
inserted
replaced
3355:f1cbbee6713b | 3356:78542e2b5e35 |
---|---|
1 /* | |
2 * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. | |
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | |
4 * | |
5 * This code is free software; you can redistribute it and/or modify it | |
6 * under the terms of the GNU General Public License version 2 only, as | |
7 * published by the Free Software Foundation. | |
8 * | |
9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
12 * version 2 for more details (a copy is included in the LICENSE file that | |
13 * accompanied this code). | |
14 * | |
15 * You should have received a copy of the GNU General Public License version | |
16 * 2 along with this work; if not, write to the Free Software Foundation, | |
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
18 * | |
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | |
20 * or visit www.oracle.com if you need additional information or have any | |
21 * questions. | |
22 * | |
23 */ | |
24 | |
25 #include "precompiled.hpp" | |
26 #include "classfile/systemDictionary.hpp" | |
27 #include "classfile/vmSymbols.hpp" | |
28 #include "oops/oop.inline.hpp" | |
29 #include "runtime/interfaceSupport.hpp" | |
30 #include "runtime/java.hpp" | |
31 #include "runtime/javaCalls.hpp" | |
32 #include "runtime/mutex.hpp" | |
33 #include "runtime/mutexLocker.hpp" | |
34 #include "services/gcNotifier.hpp" | |
35 #include "services/management.hpp" | |
36 #include "services/memoryService.hpp" | |
37 #include "memoryManager.hpp" | |
38 #include "memory/oopFactory.hpp" | |
39 | |
40 GCNotificationRequest *GCNotifier::first_request = NULL; | |
41 GCNotificationRequest *GCNotifier::last_request = NULL; | |
42 | |
43 void GCNotifier::pushNotification(GCMemoryManager *mgr, const char *action, const char *cause) { | |
44 // Make a copy of the last GC statistics | |
45 // GC may occur between now and the creation of the notification | |
46 int num_pools = MemoryService::num_memory_pools(); | |
47 GCStatInfo* stat = new GCStatInfo(num_pools); | |
48 mgr->get_last_gc_stat(stat); | |
49 GCNotificationRequest *request = new GCNotificationRequest(os::javaTimeMillis(),mgr,action,cause,stat); | |
50 addRequest(request); | |
51 } | |
52 | |
53 void GCNotifier::addRequest(GCNotificationRequest *request) { | |
54 MutexLockerEx ml(Service_lock, Mutex::_no_safepoint_check_flag); | |
55 if(first_request == NULL) { | |
56 first_request = request; | |
57 } else { | |
58 last_request->next = request; | |
59 } | |
60 last_request = request; | |
61 Service_lock->notify_all(); | |
62 } | |
63 | |
64 GCNotificationRequest *GCNotifier::getRequest() { | |
65 MutexLockerEx ml(Service_lock, Mutex::_no_safepoint_check_flag); | |
66 GCNotificationRequest *request = first_request; | |
67 if(first_request != NULL) { | |
68 first_request = first_request->next; | |
69 } | |
70 return request; | |
71 } | |
72 | |
73 bool GCNotifier::has_event() { | |
74 return first_request != NULL; | |
75 } | |
76 | |
77 static Handle getGcInfoBuilder(GCMemoryManager *gcManager,TRAPS) { | |
78 | |
79 klassOop k = Management::sun_management_GarbageCollectorImpl_klass(CHECK_NH); | |
80 instanceKlassHandle gcMBeanKlass (THREAD, k); | |
81 | |
82 instanceOop i = gcManager->get_memory_manager_instance(THREAD); | |
83 instanceHandle ih(THREAD, i); | |
84 | |
85 JavaValue result(T_OBJECT); | |
86 JavaCallArguments args(ih); | |
87 | |
88 JavaCalls::call_virtual(&result, | |
89 gcMBeanKlass, | |
90 vmSymbols::getGcInfoBuilder_name(), | |
91 vmSymbols::getGcInfoBuilder_signature(), | |
92 &args, | |
93 CHECK_NH); | |
94 return Handle(THREAD,(oop)result.get_jobject()); | |
95 | |
96 } | |
97 | |
98 static Handle createGcInfo(GCMemoryManager *gcManager, GCStatInfo *gcStatInfo,TRAPS) { | |
99 | |
100 // Fill the arrays of MemoryUsage objects with before and after GC | |
101 // per pool memory usage | |
102 | |
103 klassOop muKlass = Management::java_lang_management_MemoryUsage_klass(CHECK_NH); objArrayOop bu = oopFactory::new_objArray( muKlass,MemoryService::num_memory_pools(), CHECK_NH); | |
104 objArrayHandle usage_before_gc_ah(THREAD, bu); | |
105 objArrayOop au = oopFactory::new_objArray(muKlass,MemoryService::num_memory_pools(), CHECK_NH); | |
106 objArrayHandle usage_after_gc_ah(THREAD, au); | |
107 | |
108 for (int i = 0; i < MemoryService::num_memory_pools(); i++) { | |
109 Handle before_usage = MemoryService::create_MemoryUsage_obj(gcStatInfo->before_gc_usage_for_pool(i), CHECK_NH); | |
110 Handle after_usage; | |
111 | |
112 MemoryUsage u = gcStatInfo->after_gc_usage_for_pool(i); | |
113 if (u.max_size() == 0 && u.used() > 0) { | |
114 // If max size == 0, this pool is a survivor space. | |
115 // Set max size = -1 since the pools will be swapped after GC. | |
116 MemoryUsage usage(u.init_size(), u.used(), u.committed(), (size_t)-1); | |
117 after_usage = MemoryService::create_MemoryUsage_obj(usage, CHECK_NH); | |
118 } else { | |
119 after_usage = MemoryService::create_MemoryUsage_obj(u, CHECK_NH); | |
120 } | |
121 usage_before_gc_ah->obj_at_put(i, before_usage()); | |
122 usage_after_gc_ah->obj_at_put(i, after_usage()); | |
123 } | |
124 | |
125 // Current implementation only has 1 attribute (number of GC threads) | |
126 // The type is 'I' | |
127 objArrayOop extra_args_array = oopFactory::new_objArray(SystemDictionary::Integer_klass(), 1, CHECK_NH); | |
128 objArrayHandle extra_array (THREAD, extra_args_array); | |
129 klassOop itKlass= SystemDictionary::Integer_klass(); | |
130 instanceKlassHandle intK(THREAD, itKlass); | |
131 | |
132 instanceHandle extra_arg_val = intK->allocate_instance_handle(CHECK_NH); | |
133 | |
134 { | |
135 JavaValue res(T_VOID); | |
136 JavaCallArguments argsInt; | |
137 argsInt.push_oop(extra_arg_val); | |
138 argsInt.push_int(gcManager->num_gc_threads()); | |
139 | |
140 JavaCalls::call_special(&res, | |
141 intK, | |
142 vmSymbols::object_initializer_name(), | |
143 vmSymbols::int_void_signature(), | |
144 &argsInt, | |
145 CHECK_NH); | |
146 } | |
147 extra_array->obj_at_put(0,extra_arg_val()); | |
148 | |
149 klassOop gcInfoklass = Management::com_sun_management_GcInfo_klass(CHECK_NH); | |
150 instanceKlassHandle ik (THREAD,gcInfoklass); | |
151 | |
152 Handle gcInfo_instance = ik->allocate_instance_handle(CHECK_NH); | |
153 | |
154 JavaValue constructor_result(T_VOID); | |
155 JavaCallArguments constructor_args(16); | |
156 constructor_args.push_oop(gcInfo_instance); | |
157 constructor_args.push_oop(getGcInfoBuilder(gcManager,THREAD)); | |
158 constructor_args.push_long(gcStatInfo->gc_index()); | |
159 constructor_args.push_long(gcStatInfo->start_time()); | |
160 constructor_args.push_long(gcStatInfo->end_time()); | |
161 constructor_args.push_oop(usage_before_gc_ah); | |
162 constructor_args.push_oop(usage_after_gc_ah); | |
163 constructor_args.push_oop(extra_array); | |
164 | |
165 JavaCalls::call_special(&constructor_result, | |
166 ik, | |
167 vmSymbols::object_initializer_name(), | |
168 vmSymbols::com_sun_management_GcInfo_constructor_signature(), | |
169 &constructor_args, | |
170 CHECK_NH); | |
171 | |
172 return Handle(gcInfo_instance()); | |
173 } | |
174 | |
175 void GCNotifier::sendNotification(TRAPS) { | |
176 ResourceMark rm(THREAD); | |
177 GCNotificationRequest *request = getRequest(); | |
178 if(request != NULL) { | |
179 Handle objGcInfo = createGcInfo(request->gcManager,request->gcStatInfo,THREAD); | |
180 | |
181 Handle objName = java_lang_String::create_from_platform_dependent_str(request->gcManager->name(), CHECK); | |
182 Handle objAction = java_lang_String::create_from_platform_dependent_str(request->gcAction, CHECK); | |
183 Handle objCause = java_lang_String::create_from_platform_dependent_str(request->gcCause, CHECK); | |
184 | |
185 klassOop k = Management::sun_management_GarbageCollectorImpl_klass(CHECK); | |
186 instanceKlassHandle gc_mbean_klass (THREAD, k); | |
187 | |
188 instanceOop gc_mbean = request->gcManager->get_memory_manager_instance(THREAD); | |
189 instanceHandle gc_mbean_h(THREAD, gc_mbean); | |
190 if (!gc_mbean_h->is_a(k)) { | |
191 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), | |
192 "This GCMemoryManager doesn't have a GarbageCollectorMXBean"); | |
193 } | |
194 | |
195 JavaValue result(T_VOID); | |
196 JavaCallArguments args(gc_mbean_h); | |
197 args.push_long(request->timestamp); | |
198 args.push_oop(objName); | |
199 args.push_oop(objAction); | |
200 args.push_oop(objCause); | |
201 args.push_oop(objGcInfo); | |
202 | |
203 JavaCalls::call_virtual(&result, | |
204 gc_mbean_klass, | |
205 vmSymbols::createGCNotification_name(), | |
206 vmSymbols::createGCNotification_signature(), | |
207 &args, | |
208 CHECK); | |
209 if (HAS_PENDING_EXCEPTION) { | |
210 CLEAR_PENDING_EXCEPTION; | |
211 } | |
212 | |
213 delete request; | |
214 } | |
215 } | |
216 |