|
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 |