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