1 /*
2 * Copyright (c) 2011, 2016, 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/objArrayOop.inline.hpp"
29 #include "oops/oop.inline.hpp"
30 #include "runtime/interfaceSupport.hpp"
31 #include "runtime/java.hpp"
32 #include "runtime/javaCalls.hpp"
33 #include "runtime/mutex.hpp"
34 #include "runtime/mutexLocker.hpp"
35 #include "services/gcNotifier.hpp"
36 #include "services/management.hpp"
37 #include "services/memoryService.hpp"
38 #include "memoryManager.hpp"
39 #include "memory/oopFactory.hpp"
40 #include "memory/resourceArea.hpp"
41
42 GCNotificationRequest *GCNotifier::first_request = NULL;
43 GCNotificationRequest *GCNotifier::last_request = NULL;
44
45 void GCNotifier::pushNotification(GCMemoryManager *mgr, const char *action, const char *cause) {
46 // Make a copy of the last GC statistics
47 // GC may occur between now and the creation of the notification
48 int num_pools = MemoryService::num_memory_pools();
49 // stat is deallocated inside GCNotificationRequest
50 GCStatInfo* stat = new(ResourceObj::C_HEAP, mtGC) GCStatInfo(num_pools);
51 mgr->get_last_gc_stat(stat);
52 GCNotificationRequest *request = new GCNotificationRequest(os::javaTimeMillis(),mgr,action,cause,stat);
53 addRequest(request);
54 }
55
56 void GCNotifier::addRequest(GCNotificationRequest *request) {
57 MutexLockerEx ml(Service_lock, Mutex::_no_safepoint_check_flag);
58 if(first_request == NULL) {
59 first_request = request;
60 } else {
61 last_request->next = request;
62 }
63 last_request = request;
64 Service_lock->notify_all();
65 }
66
67 GCNotificationRequest *GCNotifier::getRequest() {
68 MutexLockerEx ml(Service_lock, Mutex::_no_safepoint_check_flag);
69 GCNotificationRequest *request = first_request;
70 if(first_request != NULL) {
71 first_request = first_request->next;
72 }
73 return request;
74 }
75
76 bool GCNotifier::has_event() {
77 return first_request != NULL;
78 }
79
80 static Handle getGcInfoBuilder(GCMemoryManager *gcManager,TRAPS) {
81
82 Klass* k = Management::com_sun_management_internal_GarbageCollectorExtImpl_klass(CHECK_NH);
83 instanceKlassHandle gcMBeanKlass (THREAD, k);
84
85 instanceOop i = gcManager->get_memory_manager_instance(THREAD);
86 instanceHandle ih(THREAD, i);
87
88 JavaValue result(T_OBJECT);
89 JavaCallArguments args(ih);
90
91 JavaCalls::call_virtual(&result,
92 gcMBeanKlass,
93 vmSymbols::getGcInfoBuilder_name(),
94 vmSymbols::getGcInfoBuilder_signature(),
95 &args,
96 CHECK_NH);
97 return Handle(THREAD,(oop)result.get_jobject());
98 }
99
100 static Handle createGcInfo(GCMemoryManager *gcManager, GCStatInfo *gcStatInfo,TRAPS) {
101
102 // Fill the arrays of MemoryUsage objects with before and after GC
103 // per pool memory usage
104
105 Klass* mu_klass = Management::java_lang_management_MemoryUsage_klass(CHECK_NH);
106 instanceKlassHandle mu_kh(THREAD, mu_klass);
107
108 // The array allocations below should use a handle containing mu_klass
109 // as the first allocation could trigger a GC, causing the actual
110 // klass oop to move, and leaving mu_klass pointing to the old
111 // location.
112 objArrayOop bu = oopFactory::new_objArray(mu_kh(), MemoryService::num_memory_pools(), CHECK_NH);
113 objArrayHandle usage_before_gc_ah(THREAD, bu);
114 objArrayOop au = oopFactory::new_objArray(mu_kh(), MemoryService::num_memory_pools(), CHECK_NH);
115 objArrayHandle usage_after_gc_ah(THREAD, au);
116
117 for (int i = 0; i < MemoryService::num_memory_pools(); i++) {
118 Handle before_usage = MemoryService::create_MemoryUsage_obj(gcStatInfo->before_gc_usage_for_pool(i), CHECK_NH);
119 Handle after_usage;
120
121 MemoryUsage u = gcStatInfo->after_gc_usage_for_pool(i);
122 if (u.max_size() == 0 && u.used() > 0) {
123 // If max size == 0, this pool is a survivor space.
124 // Set max size = -1 since the pools will be swapped after GC.
125 MemoryUsage usage(u.init_size(), u.used(), u.committed(), (size_t)-1);
126 after_usage = MemoryService::create_MemoryUsage_obj(usage, CHECK_NH);
127 } else {
128 after_usage = MemoryService::create_MemoryUsage_obj(u, CHECK_NH);
129 }
130 usage_before_gc_ah->obj_at_put(i, before_usage());
131 usage_after_gc_ah->obj_at_put(i, after_usage());
132 }
133
134 // Current implementation only has 1 attribute (number of GC threads)
135 // The type is 'I'
136 objArrayOop extra_args_array = oopFactory::new_objArray(SystemDictionary::Integer_klass(), 1, CHECK_NH);
137 objArrayHandle extra_array (THREAD, extra_args_array);
138 Klass* itKlass = SystemDictionary::Integer_klass();
139 instanceKlassHandle intK(THREAD, itKlass);
140
141 instanceHandle extra_arg_val = intK->allocate_instance_handle(CHECK_NH);
142
143 {
144 JavaValue res(T_VOID);
145 JavaCallArguments argsInt;
146 argsInt.push_oop(extra_arg_val);
147 argsInt.push_int(gcManager->num_gc_threads());
148
149 JavaCalls::call_special(&res,
150 intK,
151 vmSymbols::object_initializer_name(),
152 vmSymbols::int_void_signature(),
153 &argsInt,
154 CHECK_NH);
155 }
156 extra_array->obj_at_put(0,extra_arg_val());
157
158 Klass* gcInfoklass = Management::com_sun_management_GcInfo_klass(CHECK_NH);
159 instanceKlassHandle ik(THREAD, gcInfoklass);
160
161 Handle gcInfo_instance = ik->allocate_instance_handle(CHECK_NH);
162
163 JavaValue constructor_result(T_VOID);
164 JavaCallArguments constructor_args(16);
165 constructor_args.push_oop(gcInfo_instance);
166 constructor_args.push_oop(getGcInfoBuilder(gcManager,THREAD));
167 constructor_args.push_long(gcStatInfo->gc_index());
168 constructor_args.push_long(Management::ticks_to_ms(gcStatInfo->start_time()));
169 constructor_args.push_long(Management::ticks_to_ms(gcStatInfo->end_time()));
170 constructor_args.push_oop(usage_before_gc_ah);
171 constructor_args.push_oop(usage_after_gc_ah);
172 constructor_args.push_oop(extra_array);
173
174 JavaCalls::call_special(&constructor_result,
175 ik,
176 vmSymbols::object_initializer_name(),
177 vmSymbols::com_sun_management_GcInfo_constructor_signature(),
178 &constructor_args,
179 CHECK_NH);
180
181 return Handle(gcInfo_instance());
182 }
183
184 void GCNotifier::sendNotification(TRAPS) {
185 GCNotifier::sendNotificationInternal(THREAD);
186 // Clearing pending exception to avoid premature termination of
187 // the service thread
188 if (HAS_PENDING_EXCEPTION) {
189 CLEAR_PENDING_EXCEPTION;
190 }
191 }
192
193 class NotificationMark : public StackObj {
194 // This class is used in GCNotifier::sendNotificationInternal to ensure that
195 // the GCNotificationRequest object is properly cleaned up, whatever path
196 // is used to exit the method.
197 GCNotificationRequest* _request;
198 public:
199 NotificationMark(GCNotificationRequest* r) {
200 _request = r;
201 }
202 ~NotificationMark() {
203 assert(_request != NULL, "Sanity check");
204 delete _request;
205 }
206 };
207
208 void GCNotifier::sendNotificationInternal(TRAPS) {
209 ResourceMark rm(THREAD);
210 HandleMark hm(THREAD);
211 GCNotificationRequest *request = getRequest();
212 if (request != NULL) {
213 NotificationMark nm(request);
214 Handle objGcInfo = createGcInfo(request->gcManager, request->gcStatInfo, CHECK);
215
216 Handle objName = java_lang_String::create_from_str(request->gcManager->name(), CHECK);
217 Handle objAction = java_lang_String::create_from_str(request->gcAction, CHECK);
218 Handle objCause = java_lang_String::create_from_str(request->gcCause, CHECK);
219 Klass* k = Management::com_sun_management_internal_GarbageCollectorExtImpl_klass(CHECK);
220
221 instanceKlassHandle gc_mbean_klass(THREAD, k);
222
223 instanceOop gc_mbean = request->gcManager->get_memory_manager_instance(THREAD);
224 instanceHandle gc_mbean_h(THREAD, gc_mbean);
225 if (!gc_mbean_h->is_a(k)) {
226 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
227 "This GCMemoryManager doesn't have a GarbageCollectorMXBean");
228 }
229
230 JavaValue result(T_VOID);
231 JavaCallArguments args(gc_mbean_h);
232 args.push_long(request->timestamp);
233 args.push_oop(objName);
234 args.push_oop(objAction);
235 args.push_oop(objCause);
236 args.push_oop(objGcInfo);
237
238 JavaCalls::call_virtual(&result,
239 gc_mbean_klass,
240 vmSymbols::createGCNotification_name(),
241 vmSymbols::createGCNotification_signature(),
242 &args,
243 CHECK);
244 }
245 }
246