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