Mercurial > hg > truffle
view src/share/vm/services/gcNotifier.cpp @ 7196:2aff40cb4703
7092905: C2: Keep track of the number of dead nodes
Summary: keep an (almost) accurate running count of the reachable (live) flow graph nodes.
Reviewed-by: kvn, twisti, jrose, vlivanov
author | bharadwaj |
---|---|
date | Tue, 27 Nov 2012 17:24:15 -0800 |
parents | da91efe96a93 |
children | 32e3bada0978 |
line wrap: on
line source
/* * Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. * */ #include "precompiled.hpp" #include "classfile/systemDictionary.hpp" #include "classfile/vmSymbols.hpp" #include "oops/oop.inline.hpp" #include "runtime/interfaceSupport.hpp" #include "runtime/java.hpp" #include "runtime/javaCalls.hpp" #include "runtime/mutex.hpp" #include "runtime/mutexLocker.hpp" #include "services/gcNotifier.hpp" #include "services/management.hpp" #include "services/memoryService.hpp" #include "memoryManager.hpp" #include "memory/oopFactory.hpp" GCNotificationRequest *GCNotifier::first_request = NULL; GCNotificationRequest *GCNotifier::last_request = NULL; void GCNotifier::pushNotification(GCMemoryManager *mgr, const char *action, const char *cause) { // Make a copy of the last GC statistics // GC may occur between now and the creation of the notification int num_pools = MemoryService::num_memory_pools(); // stat is deallocated inside GCNotificationRequest GCStatInfo* stat = new(ResourceObj::C_HEAP, mtGC) GCStatInfo(num_pools); mgr->get_last_gc_stat(stat); GCNotificationRequest *request = new GCNotificationRequest(os::javaTimeMillis(),mgr,action,cause,stat); addRequest(request); } void GCNotifier::addRequest(GCNotificationRequest *request) { MutexLockerEx ml(Service_lock, Mutex::_no_safepoint_check_flag); if(first_request == NULL) { first_request = request; } else { last_request->next = request; } last_request = request; Service_lock->notify_all(); } GCNotificationRequest *GCNotifier::getRequest() { MutexLockerEx ml(Service_lock, Mutex::_no_safepoint_check_flag); GCNotificationRequest *request = first_request; if(first_request != NULL) { first_request = first_request->next; } return request; } bool GCNotifier::has_event() { return first_request != NULL; } static Handle getGcInfoBuilder(GCMemoryManager *gcManager,TRAPS) { Klass* k = Management::sun_management_GarbageCollectorImpl_klass(CHECK_NH); instanceKlassHandle gcMBeanKlass (THREAD, k); instanceOop i = gcManager->get_memory_manager_instance(THREAD); instanceHandle ih(THREAD, i); JavaValue result(T_OBJECT); JavaCallArguments args(ih); JavaCalls::call_virtual(&result, gcMBeanKlass, vmSymbols::getGcInfoBuilder_name(), vmSymbols::getGcInfoBuilder_signature(), &args, CHECK_NH); return Handle(THREAD,(oop)result.get_jobject()); } static Handle createGcInfo(GCMemoryManager *gcManager, GCStatInfo *gcStatInfo,TRAPS) { // Fill the arrays of MemoryUsage objects with before and after GC // per pool memory usage Klass* mu_klass = Management::java_lang_management_MemoryUsage_klass(CHECK_NH); instanceKlassHandle mu_kh(THREAD, mu_klass); // The array allocations below should use a handle containing mu_klass // as the first allocation could trigger a GC, causing the actual // klass oop to move, and leaving mu_klass pointing to the old // location. objArrayOop bu = oopFactory::new_objArray(mu_kh(), MemoryService::num_memory_pools(), CHECK_NH); objArrayHandle usage_before_gc_ah(THREAD, bu); objArrayOop au = oopFactory::new_objArray(mu_kh(), MemoryService::num_memory_pools(), CHECK_NH); objArrayHandle usage_after_gc_ah(THREAD, au); for (int i = 0; i < MemoryService::num_memory_pools(); i++) { Handle before_usage = MemoryService::create_MemoryUsage_obj(gcStatInfo->before_gc_usage_for_pool(i), CHECK_NH); Handle after_usage; MemoryUsage u = gcStatInfo->after_gc_usage_for_pool(i); if (u.max_size() == 0 && u.used() > 0) { // If max size == 0, this pool is a survivor space. // Set max size = -1 since the pools will be swapped after GC. MemoryUsage usage(u.init_size(), u.used(), u.committed(), (size_t)-1); after_usage = MemoryService::create_MemoryUsage_obj(usage, CHECK_NH); } else { after_usage = MemoryService::create_MemoryUsage_obj(u, CHECK_NH); } usage_before_gc_ah->obj_at_put(i, before_usage()); usage_after_gc_ah->obj_at_put(i, after_usage()); } // Current implementation only has 1 attribute (number of GC threads) // The type is 'I' objArrayOop extra_args_array = oopFactory::new_objArray(SystemDictionary::Integer_klass(), 1, CHECK_NH); objArrayHandle extra_array (THREAD, extra_args_array); Klass* itKlass = SystemDictionary::Integer_klass(); instanceKlassHandle intK(THREAD, itKlass); instanceHandle extra_arg_val = intK->allocate_instance_handle(CHECK_NH); { JavaValue res(T_VOID); JavaCallArguments argsInt; argsInt.push_oop(extra_arg_val); argsInt.push_int(gcManager->num_gc_threads()); JavaCalls::call_special(&res, intK, vmSymbols::object_initializer_name(), vmSymbols::int_void_signature(), &argsInt, CHECK_NH); } extra_array->obj_at_put(0,extra_arg_val()); Klass* gcInfoklass = Management::com_sun_management_GcInfo_klass(CHECK_NH); instanceKlassHandle ik(THREAD, gcInfoklass); Handle gcInfo_instance = ik->allocate_instance_handle(CHECK_NH); JavaValue constructor_result(T_VOID); JavaCallArguments constructor_args(16); constructor_args.push_oop(gcInfo_instance); constructor_args.push_oop(getGcInfoBuilder(gcManager,THREAD)); constructor_args.push_long(gcStatInfo->gc_index()); constructor_args.push_long(Management::ticks_to_ms(gcStatInfo->start_time())); constructor_args.push_long(Management::ticks_to_ms(gcStatInfo->end_time())); constructor_args.push_oop(usage_before_gc_ah); constructor_args.push_oop(usage_after_gc_ah); constructor_args.push_oop(extra_array); JavaCalls::call_special(&constructor_result, ik, vmSymbols::object_initializer_name(), vmSymbols::com_sun_management_GcInfo_constructor_signature(), &constructor_args, CHECK_NH); return Handle(gcInfo_instance()); } void GCNotifier::sendNotification(TRAPS) { GCNotifier::sendNotificationInternal(THREAD); // Clearing pending exception to avoid premature termination of // the service thread if (HAS_PENDING_EXCEPTION) { CLEAR_PENDING_EXCEPTION; } } class NotificationMark : public StackObj { // This class is used in GCNotifier::sendNotificationInternal to ensure that // the GCNotificationRequest object is properly cleaned up, whatever path // is used to exit the method. GCNotificationRequest* _request; public: NotificationMark(GCNotificationRequest* r) { _request = r; } ~NotificationMark() { assert(_request != NULL, "Sanity check"); delete _request; } }; void GCNotifier::sendNotificationInternal(TRAPS) { ResourceMark rm(THREAD); HandleMark hm(THREAD); GCNotificationRequest *request = getRequest(); if (request != NULL) { NotificationMark nm(request); Handle objGcInfo = createGcInfo(request->gcManager, request->gcStatInfo, THREAD); Handle objName = java_lang_String::create_from_platform_dependent_str(request->gcManager->name(), CHECK); Handle objAction = java_lang_String::create_from_platform_dependent_str(request->gcAction, CHECK); Handle objCause = java_lang_String::create_from_platform_dependent_str(request->gcCause, CHECK); Klass* k = Management::sun_management_GarbageCollectorImpl_klass(CHECK); instanceKlassHandle gc_mbean_klass(THREAD, k); instanceOop gc_mbean = request->gcManager->get_memory_manager_instance(THREAD); instanceHandle gc_mbean_h(THREAD, gc_mbean); if (!gc_mbean_h->is_a(k)) { THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "This GCMemoryManager doesn't have a GarbageCollectorMXBean"); } JavaValue result(T_VOID); JavaCallArguments args(gc_mbean_h); args.push_long(request->timestamp); args.push_oop(objName); args.push_oop(objAction); args.push_oop(objCause); args.push_oop(objGcInfo); JavaCalls::call_virtual(&result, gc_mbean_klass, vmSymbols::createGCNotification_name(), vmSymbols::createGCNotification_signature(), &args, CHECK); } }