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