1 /*

     2  * Copyright 2002-2007 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    20  * CA 95054 USA or visit www.sun.com if you need additional information or

    21  * have any questions.

    22  *

    23  */

    24 

    25 # include "incls/_precompiled.incl"

    26 # include "incls/_heapInspection.cpp.incl"

    27 

    28 // HeapInspection

    29 

    30 int KlassInfoEntry::compare(KlassInfoEntry* e1, KlassInfoEntry* e2) {

    31   if(e1->_instance_words > e2->_instance_words) {

    32     return -1;

    33   } else if(e1->_instance_words < e2->_instance_words) {

    34     return 1;

    35   }

    36   return 0;

    37 }

    38 

    39 void KlassInfoEntry::print_on(outputStream* st) const {

    40   ResourceMark rm;

    41   const char* name;;

    42   if (_klass->klass_part()->name() != NULL) {

    43     name = _klass->klass_part()->external_name();

    44   } else {

    45     if (_klass == Universe::klassKlassObj())             name = "<klassKlass>";             else

    46     if (_klass == Universe::arrayKlassKlassObj())        name = "<arrayKlassKlass>";        else

    47     if (_klass == Universe::objArrayKlassKlassObj())     name = "<objArrayKlassKlass>";     else

    48     if (_klass == Universe::instanceKlassKlassObj())     name = "<instanceKlassKlass>";     else

    49     if (_klass == Universe::typeArrayKlassKlassObj())    name = "<typeArrayKlassKlass>";    else

    50     if (_klass == Universe::symbolKlassObj())            name = "<symbolKlass>";            else

    51     if (_klass == Universe::boolArrayKlassObj())         name = "<boolArrayKlass>";         else

    52     if (_klass == Universe::charArrayKlassObj())         name = "<charArrayKlass>";         else

    53     if (_klass == Universe::singleArrayKlassObj())       name = "<singleArrayKlass>";       else

    54     if (_klass == Universe::doubleArrayKlassObj())       name = "<doubleArrayKlass>";       else

    55     if (_klass == Universe::byteArrayKlassObj())         name = "<byteArrayKlass>";         else

    56     if (_klass == Universe::shortArrayKlassObj())        name = "<shortArrayKlass>";        else

    57     if (_klass == Universe::intArrayKlassObj())          name = "<intArrayKlass>";          else

    58     if (_klass == Universe::longArrayKlassObj())         name = "<longArrayKlass>";         else

    59     if (_klass == Universe::methodKlassObj())            name = "<methodKlass>";            else

    60     if (_klass == Universe::constMethodKlassObj())       name = "<constMethodKlass>";       else

    61     if (_klass == Universe::methodDataKlassObj())        name = "<methodDataKlass>";        else

    62     if (_klass == Universe::constantPoolKlassObj())      name = "<constantPoolKlass>";      else

    63     if (_klass == Universe::constantPoolCacheKlassObj()) name = "<constantPoolCacheKlass>"; else

    64     if (_klass == Universe::compiledICHolderKlassObj())  name = "<compiledICHolderKlass>";  else

    65       name = "<no name>";

    66   }

    67   // simplify the formatting (ILP32 vs LP64) - always cast the numbers to 64-bit

    68   st->print_cr("%13" FORMAT64_MODIFIER "d  %13" FORMAT64_MODIFIER "u  %s",

    69                (jlong)  _instance_count,

    70                (julong) _instance_words * HeapWordSize,

    71                name);

    72 }

    73 

    74 KlassInfoEntry* KlassInfoBucket::lookup(const klassOop k) {

    75   KlassInfoEntry* elt = _list;

    76   while (elt != NULL) {

    77     if (elt->is_equal(k)) {

    78       return elt;

    79     }

    80     elt = elt->next();

    81   }

    82   elt = new KlassInfoEntry(k, list());

    83   set_list(elt);

    84   return elt;

    85 }

    86 

    87 void KlassInfoBucket::iterate(KlassInfoClosure* cic) {

    88   KlassInfoEntry* elt = _list;

    89   while (elt != NULL) {

    90     cic->do_cinfo(elt);

    91     elt = elt->next();

    92   }

    93 }

    94 

    95 void KlassInfoBucket::empty() {

    96   KlassInfoEntry* elt = _list;

    97   _list = NULL;

    98   while (elt != NULL) {

    99     KlassInfoEntry* next = elt->next();

   100     delete elt;

   101     elt = next;

   102   }

   103 }

   104 

   105 KlassInfoTable::KlassInfoTable(int size, HeapWord* ref) {

   106   _size = size;

   107   _ref = ref;

   108   _buckets = NEW_C_HEAP_ARRAY(KlassInfoBucket, _size);

   109 

   110   for (int index = 0; index < _size; index++) {

   111     _buckets[index].initialize();

   112   }

   113 }

   114 

   115 KlassInfoTable::~KlassInfoTable() {

   116   for (int index = 0; index < _size; index++) {

   117     _buckets[index].empty();

   118   }

   119   FREE_C_HEAP_ARRAY(KlassInfoBucket, _buckets);

   120   _size = 0;

   121 }

   122 

   123 uint KlassInfoTable::hash(klassOop p) {

   124   assert(Universe::heap()->is_in_permanent((HeapWord*)p), "all klasses in permgen");

   125   return (uint)(((uintptr_t)p - (uintptr_t)_ref) >> 2);

   126 }

   127 

   128 KlassInfoEntry* KlassInfoTable::lookup(const klassOop k) {

   129   uint         idx = hash(k) % _size;

   130   KlassInfoEntry*  e   = _buckets[idx].lookup(k);

   131   assert(k == e->klass(), "must be equal");

   132   return e;

   133 }

   134 

   135 void KlassInfoTable::record_instance(const oop obj) {

   136   klassOop      k = obj->klass();

   137   KlassInfoEntry* elt = lookup(k);

   138   elt->set_count(elt->count() + 1);

   139   elt->set_words(elt->words() + obj->size());

   140 }

   141 

   142 void KlassInfoTable::iterate(KlassInfoClosure* cic) {

   143   for (int index = 0; index < _size; index++) {

   144     _buckets[index].iterate(cic);

   145   }

   146 }

   147 

   148 int KlassInfoHisto::sort_helper(KlassInfoEntry** e1, KlassInfoEntry** e2) {

   149   return (*e1)->compare(*e1,*e2);

   150 }

   151 

   152 KlassInfoHisto::KlassInfoHisto(const char* title, int estimatedCount) :

   153   _title(title) {

   154   _elements = new (ResourceObj::C_HEAP) GrowableArray<KlassInfoEntry*>(estimatedCount,true);

   155 }

   156 

   157 KlassInfoHisto::~KlassInfoHisto() {

   158   delete _elements;

   159 }

   160 

   161 void KlassInfoHisto::add(KlassInfoEntry* cie) {

   162   elements()->append(cie);

   163 }

   164 

   165 void KlassInfoHisto::sort() {

   166   elements()->sort(KlassInfoHisto::sort_helper);

   167 }

   168 

   169 void KlassInfoHisto::print_elements(outputStream* st) const {

   170   // simplify the formatting (ILP32 vs LP64) - store the sum in 64-bit

   171   jlong total = 0;

   172   julong totalw = 0;

   173   for(int i=0; i < elements()->length(); i++) {

   174     st->print("%4d: ", i+1);

   175     elements()->at(i)->print_on(st);

   176     total += elements()->at(i)->count();

   177     totalw += elements()->at(i)->words();

   178   }

   179   st->print_cr("Total %13" FORMAT64_MODIFIER "d  %13" FORMAT64_MODIFIER "u",

   180                total, totalw * HeapWordSize);

   181 }

   182 

   183 void KlassInfoHisto::print_on(outputStream* st) const {

   184   st->print_cr("%s",title());

   185   print_elements(st);

   186 }

   187 

   188 class HistoClosure : public KlassInfoClosure {

   189  private:

   190   KlassInfoHisto* _cih;

   191  public:

   192   HistoClosure(KlassInfoHisto* cih) : _cih(cih) {}

   193 

   194   void do_cinfo(KlassInfoEntry* cie) {

   195     _cih->add(cie);

   196   }

   197 };

   198 

   199 class RecordInstanceClosure : public ObjectClosure {

   200  private:

   201   KlassInfoTable* _cit;

   202  public:

   203   RecordInstanceClosure(KlassInfoTable* cit) : _cit(cit) {}

   204 

   205   void do_object(oop obj) {

   206     _cit->record_instance(obj);

   207   }

   208 };

   209 

   210 void HeapInspection::heap_inspection(outputStream* st) {

   211   ResourceMark rm;

   212   HeapWord* ref;

   213 

   214   CollectedHeap* heap = Universe::heap();

   215   switch (heap->kind()) {

   216     case CollectedHeap::GenCollectedHeap: {

   217       GenCollectedHeap* gch = (GenCollectedHeap*)heap;

   218       gch->gc_prologue(false /* !full */); // get any necessary locks

   219       ref = gch->perm_gen()->used_region().start();

   220       break;

   221     }

   222 #ifndef SERIALGC

   223     case CollectedHeap::ParallelScavengeHeap: {

   224       ParallelScavengeHeap* psh = (ParallelScavengeHeap*)heap;

   225       ref = psh->perm_gen()->object_space()->used_region().start();

   226       break;

   227     }

   228 #endif // SERIALGC

   229     default:

   230       ShouldNotReachHere(); // Unexpected heap kind for this op

   231   }

   232   // Collect klass instance info

   233 

   234   // Iterate over objects in the heap

   235   KlassInfoTable cit(KlassInfoTable::cit_size, ref);

   236   RecordInstanceClosure ric(&cit);

   237   Universe::heap()->object_iterate(&ric);

   238 

   239   // Sort and print klass instance info

   240   KlassInfoHisto histo("\n"

   241                    " num     #instances         #bytes  class name\n"

   242                    "----------------------------------------------",

   243                    KlassInfoHisto::histo_initial_size);

   244   HistoClosure hc(&histo);

   245   cit.iterate(&hc);

   246   histo.sort();

   247   histo.print_on(st);

   248   st->flush();

   249 

   250   if (Universe::heap()->kind() == CollectedHeap::GenCollectedHeap) {

   251     GenCollectedHeap* gch = GenCollectedHeap::heap();

   252     gch->gc_epilogue(false /* !full */); // release all acquired locks

   253   }

   254 }

   255 

   256 class FindInstanceClosure : public ObjectClosure {

   257  private:

   258   klassOop _klass;

   259   GrowableArray<oop>* _result;

   260 

   261  public:

   262   FindInstanceClosure(klassOop k, GrowableArray<oop>* result) : _klass(k), _result(result) {};

   263 

   264   void do_object(oop obj) {

   265     if (obj->is_a(_klass)) {

   266       _result->append(obj);

   267     }

   268   }

   269 };

   270 

   271 void HeapInspection::find_instances_at_safepoint(klassOop k, GrowableArray<oop>* result) {

   272   assert(SafepointSynchronize::is_at_safepoint(), "all threads are stopped");

   273   assert(Heap_lock->is_locked(), "should have the Heap_lock")

   274 

   275   // Ensure that the heap is parsable

   276   Universe::heap()->ensure_parsability(false);  // no need to retire TALBs

   277 

   278   // Iterate over objects in the heap

   279   FindInstanceClosure fic(k, result);

   280   Universe::heap()->object_iterate(&fic);

   281 }