1 /*
   2  * Copyright (c) 2002, 2013, 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/classLoaderData.hpp"
  27 #include "gc_interface/collectedHeap.hpp"
  28 #include "memory/genCollectedHeap.hpp"
  29 #include "memory/heapInspection.hpp"
  30 #include "memory/resourceArea.hpp"
  31 #include "runtime/os.hpp"
  32 #include "utilities/globalDefinitions.hpp"
  33 #include "utilities/macros.hpp"
  34 #if INCLUDE_ALL_GCS
  35 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"
  36 #endif // INCLUDE_ALL_GCS
  37 
  38 // HeapInspection
  39 
  40 int KlassInfoEntry::compare(KlassInfoEntry* e1, KlassInfoEntry* e2) {
  41   if(e1->_instance_words > e2->_instance_words) {
  42     return -1;
  43   } else if(e1->_instance_words < e2->_instance_words) {
  44     return 1;
  45   }
  46   // Sort alphabetically, note 'Z' < '[' < 'a', but it's better to group
  47   // the array classes before all the instance classes.
  48   ResourceMark rm;
  49   const char* name1 = e1->klass()->external_name();
  50   const char* name2 = e2->klass()->external_name();
  51   bool d1 = (name1[0] == '[');
  52   bool d2 = (name2[0] == '[');
  53   if (d1 && !d2) {
  54     return -1;
  55   } else if (d2 && !d1) {
  56     return 1;
  57   } else {
  58     return strcmp(name1, name2);
  59   }
  60 }
  61 
  62 const char* KlassInfoEntry::name() const {
  63   const char* name;
  64   if (_klass->name() != NULL) {
  65     name = _klass->external_name();
  66   } else {
  67     if (_klass == Universe::boolArrayKlassObj())         name = "<boolArrayKlass>";         else
  68     if (_klass == Universe::charArrayKlassObj())         name = "<charArrayKlass>";         else
  69     if (_klass == Universe::singleArrayKlassObj())       name = "<singleArrayKlass>";       else
  70     if (_klass == Universe::doubleArrayKlassObj())       name = "<doubleArrayKlass>";       else
  71     if (_klass == Universe::byteArrayKlassObj())         name = "<byteArrayKlass>";         else
  72     if (_klass == Universe::shortArrayKlassObj())        name = "<shortArrayKlass>";        else
  73     if (_klass == Universe::intArrayKlassObj())          name = "<intArrayKlass>";          else
  74     if (_klass == Universe::longArrayKlassObj())         name = "<longArrayKlass>";         else
  75       name = "<no name>";
  76   }
  77   return name;
  78 }
  79 
  80 void KlassInfoEntry::print_on(outputStream* st) const {
  81   ResourceMark rm;
  82 
  83   // simplify the formatting (ILP32 vs LP64) - always cast the numbers to 64-bit
  84   st->print_cr(INT64_FORMAT_W(13) "  " UINT64_FORMAT_W(13) "  %s",
  85                (jlong)  _instance_count,
  86                (julong) _instance_words * HeapWordSize,
  87                name());
  88 }
  89 
  90 KlassInfoEntry* KlassInfoBucket::lookup(Klass* const k) {
  91   KlassInfoEntry* elt = _list;
  92   while (elt != NULL) {
  93     if (elt->is_equal(k)) {
  94       return elt;
  95     }
  96     elt = elt->next();
  97   }
  98   elt = new KlassInfoEntry(k, list());
  99   // We may be out of space to allocate the new entry.
 100   if (elt != NULL) {
 101     set_list(elt);
 102   }
 103   return elt;
 104 }
 105 
 106 void KlassInfoBucket::iterate(KlassInfoClosure* cic) {
 107   KlassInfoEntry* elt = _list;
 108   while (elt != NULL) {
 109     cic->do_cinfo(elt);
 110     elt = elt->next();
 111   }
 112 }
 113 
 114 void KlassInfoBucket::empty() {
 115   KlassInfoEntry* elt = _list;
 116   _list = NULL;
 117   while (elt != NULL) {
 118     KlassInfoEntry* next = elt->next();
 119     delete elt;
 120     elt = next;
 121   }
 122 }
 123 
 124 void KlassInfoTable::AllClassesFinder::do_klass(Klass* k) {
 125   // This has the SIDE EFFECT of creating a KlassInfoEntry
 126   // for <k>, if one doesn't exist yet.
 127   _table->lookup(k);
 128 }
 129 
 130 KlassInfoTable::KlassInfoTable(int size, HeapWord* ref,
 131                                bool need_class_stats) {
 132   _size = 0;
 133   _ref = ref;
 134   _buckets = NEW_C_HEAP_ARRAY(KlassInfoBucket, size, mtInternal);
 135   if (_buckets != NULL) {
 136     _size = size;
 137     for (int index = 0; index < _size; index++) {
 138       _buckets[index].initialize();
 139     }
 140     if (need_class_stats) {
 141       AllClassesFinder finder(this);
 142       ClassLoaderDataGraph::classes_do(&finder);
 143     }
 144   }
 145 }
 146 
 147 KlassInfoTable::~KlassInfoTable() {
 148   if (_buckets != NULL) {
 149     for (int index = 0; index < _size; index++) {
 150       _buckets[index].empty();
 151     }
 152     FREE_C_HEAP_ARRAY(KlassInfoBucket, _buckets, mtInternal);
 153     _size = 0;
 154   }
 155 }
 156 
 157 uint KlassInfoTable::hash(const Klass* p) {
 158   assert(p->is_metadata(), "all klasses are metadata");
 159   return (uint)(((uintptr_t)p - (uintptr_t)_ref) >> 2);
 160 }
 161 
 162 KlassInfoEntry* KlassInfoTable::lookup(Klass* k) {
 163   uint         idx = hash(k) % _size;
 164   assert(_buckets != NULL, "Allocation failure should have been caught");
 165   KlassInfoEntry*  e   = _buckets[idx].lookup(k);
 166   // Lookup may fail if this is a new klass for which we
 167   // could not allocate space for an new entry.
 168   assert(e == NULL || k == e->klass(), "must be equal");
 169   return e;
 170 }
 171 
 172 // Return false if the entry could not be recorded on account
 173 // of running out of space required to create a new entry.
 174 bool KlassInfoTable::record_instance(const oop obj) {
 175   Klass*        k = obj->klass();
 176   KlassInfoEntry* elt = lookup(k);
 177   // elt may be NULL if it's a new klass for which we
 178   // could not allocate space for a new entry in the hashtable.
 179   if (elt != NULL) {
 180     elt->set_count(elt->count() + 1);
 181     elt->set_words(elt->words() + obj->size());
 182     return true;
 183   } else {
 184     return false;
 185   }
 186 }
 187 
 188 void KlassInfoTable::iterate(KlassInfoClosure* cic) {
 189   assert(_size == 0 || _buckets != NULL, "Allocation failure should have been caught");
 190   for (int index = 0; index < _size; index++) {
 191     _buckets[index].iterate(cic);
 192   }
 193 }
 194 
 195 int KlassInfoHisto::sort_helper(KlassInfoEntry** e1, KlassInfoEntry** e2) {
 196   return (*e1)->compare(*e1,*e2);
 197 }
 198 
 199 KlassInfoHisto::KlassInfoHisto(KlassInfoTable* cit, const char* title, int estimatedCount) :
 200   _cit(cit),
 201   _title(title) {
 202   _elements = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<KlassInfoEntry*>(estimatedCount,true);
 203 }
 204 
 205 KlassInfoHisto::~KlassInfoHisto() {
 206   delete _elements;
 207 }
 208 
 209 void KlassInfoHisto::add(KlassInfoEntry* cie) {
 210   elements()->append(cie);
 211 }
 212 
 213 void KlassInfoHisto::sort() {
 214   elements()->sort(KlassInfoHisto::sort_helper);
 215 }
 216 
 217 void KlassInfoHisto::print_elements(outputStream* st) const {
 218   // simplify the formatting (ILP32 vs LP64) - store the sum in 64-bit
 219   jlong total = 0;
 220   julong totalw = 0;
 221   for(int i=0; i < elements()->length(); i++) {
 222     st->print("%4d: ", i+1);
 223     elements()->at(i)->print_on(st);
 224     total += elements()->at(i)->count();
 225     totalw += elements()->at(i)->words();
 226   }
 227   st->print_cr("Total " INT64_FORMAT_W(13) "  " UINT64_FORMAT_W(13),
 228                total, totalw * HeapWordSize);
 229 }
 230 
 231 #define MAKE_COL_NAME(field, name, help)     #name,
 232 #define MAKE_COL_HELP(field, name, help)     help,
 233 
 234 static const char *name_table[] = {
 235   HEAP_INSPECTION_COLUMNS_DO(MAKE_COL_NAME)
 236 };
 237 
 238 static const char *help_table[] = {
 239   HEAP_INSPECTION_COLUMNS_DO(MAKE_COL_HELP)
 240 };
 241 
 242 bool KlassInfoHisto::is_selected(const char *col_name) {
 243   if (_selected_columns == NULL) {
 244     return true;
 245   }
 246   if (strcmp(_selected_columns, col_name) == 0) {
 247     return true;
 248   }
 249 
 250   const char *start = strstr(_selected_columns, col_name);
 251   if (start == NULL) {
 252     return false;
 253   }
 254 
 255   // The following must be true, because _selected_columns != col_name
 256   if (start > _selected_columns && start[-1] != ',') {
 257     return false;
 258   }
 259   char x = start[strlen(col_name)];
 260   if (x != ',' && x != '\0') {
 261     return false;
 262   }
 263 
 264   return true;
 265 }
 266 
 267 void KlassInfoHisto::print_title(outputStream* st, bool csv_format,
 268                                  bool selected[], int width_table[],
 269                                  const char *name_table[]) {
 270   if (csv_format) {
 271     st->print("Index,Super");
 272     for (int c=0; c<KlassSizeStats::_num_columns; c++) {
 273        if (selected[c]) {st->print(",%s", name_table[c]);}
 274     }
 275     st->print(",ClassName");
 276   } else {
 277     st->print("Index Super");
 278     for (int c=0; c<KlassSizeStats::_num_columns; c++) {
 279       if (selected[c]) {st->print(str_fmt(width_table[c]), name_table[c]);}
 280     }
 281     st->print(" ClassName");
 282   }
 283 
 284   if (is_selected("ClassLoader")) {
 285     st->print(",ClassLoader");
 286   }
 287   st->cr();
 288 }
 289 
 290 void KlassInfoHisto::print_class_stats(outputStream* st,
 291                                       bool csv_format, const char *columns) {
 292   ResourceMark rm;
 293   KlassSizeStats sz, sz_sum;
 294   int i;
 295   julong *col_table = (julong*)(&sz);
 296   julong *colsum_table = (julong*)(&sz_sum);
 297   int width_table[KlassSizeStats::_num_columns];
 298   bool selected[KlassSizeStats::_num_columns];
 299 
 300   _selected_columns = columns;
 301 
 302   memset(&sz_sum, 0, sizeof(sz_sum));
 303   for (int c=0; c<KlassSizeStats::_num_columns; c++) {
 304     selected[c] = is_selected(name_table[c]);
 305   }
 306 
 307   for(i=0; i < elements()->length(); i++) {
 308     elements()->at(i)->set_index(i+1);
 309   }
 310 
 311   for (int pass=1; pass<=2; pass++) {
 312     if (pass == 2) {
 313       print_title(st, csv_format, selected, width_table, name_table);
 314     }
 315     for(i=0; i < elements()->length(); i++) {
 316       KlassInfoEntry* e = (KlassInfoEntry*)elements()->at(i);
 317       const Klass* k = e->klass();
 318 
 319       memset(&sz, 0, sizeof(sz));
 320       sz._inst_count = e->count();
 321       sz._inst_bytes = HeapWordSize * e->words();
 322       k->collect_statistics(&sz);
 323       sz._total_bytes = sz._ro_bytes + sz._rw_bytes;
 324 
 325       if (pass == 1) {
 326         for (int c=0; c<KlassSizeStats::_num_columns; c++) {
 327           colsum_table[c] += col_table[c];
 328         }
 329       } else {
 330         int super_index = -1;
 331         if (k->oop_is_instance()) {
 332           Klass* super = ((InstanceKlass*)k)->java_super();
 333           if (super) {
 334             KlassInfoEntry* super_e = _cit->lookup(super);
 335             if (super_e) {
 336               super_index = super_e->index();
 337             }
 338           }
 339         }
 340 
 341         if (csv_format) {
 342           st->print("%d,%d", e->index(), super_index);
 343           for (int c=0; c<KlassSizeStats::_num_columns; c++) {
 344             if (selected[c]) {st->print("," JULONG_FORMAT, col_table[c]);}
 345           }
 346           st->print(",%s",e->name());
 347         } else {
 348           st->print("%5d %5d", e->index(), super_index);
 349           for (int c=0; c<KlassSizeStats::_num_columns; c++) {
 350             if (selected[c]) {print_julong(st, width_table[c], col_table[c]);}
 351           }
 352           st->print(" %s", e->name());
 353         }
 354         if (is_selected("ClassLoader")) {
 355           ClassLoaderData* loader_data = k->class_loader_data();
 356           st->print(",");
 357           loader_data->print_value_on(st);
 358         }
 359         st->cr();
 360       }
 361     }
 362 
 363     if (pass == 1) {
 364       for (int c=0; c<KlassSizeStats::_num_columns; c++) {
 365         width_table[c] = col_width(colsum_table[c], name_table[c]);
 366       }
 367     }
 368   }
 369 
 370   sz_sum._inst_size = 0;
 371 
 372   if (csv_format) {
 373     st->print(",");
 374     for (int c=0; c<KlassSizeStats::_num_columns; c++) {
 375       if (selected[c]) {st->print("," JULONG_FORMAT, colsum_table[c]);}
 376     }
 377   } else {
 378     st->print("           ");
 379     for (int c=0; c<KlassSizeStats::_num_columns; c++) {
 380       if (selected[c]) {print_julong(st, width_table[c], colsum_table[c]);}
 381     }
 382     st->print(" Total");
 383     if (sz_sum._total_bytes > 0) {
 384       st->cr();
 385       st->print("           ");
 386       for (int c=0; c<KlassSizeStats::_num_columns; c++) {
 387         if (selected[c]) {
 388           switch (c) {
 389           case KlassSizeStats::_index_inst_size:
 390           case KlassSizeStats::_index_inst_count:
 391           case KlassSizeStats::_index_method_count:
 392             st->print(str_fmt(width_table[c]), "-");
 393             break;
 394           default:
 395             {
 396               double perc = (double)(100) * (double)(colsum_table[c]) / (double)sz_sum._total_bytes;
 397               st->print(perc_fmt(width_table[c]), perc);
 398             }
 399           }
 400         }
 401       }
 402     }
 403   }
 404   st->cr();
 405 
 406   if (!csv_format) {
 407     print_title(st, csv_format, selected, width_table, name_table);
 408   }
 409 }
 410 
 411 julong KlassInfoHisto::annotations_bytes(Array<AnnotationArray*>* p) const {
 412   julong bytes = 0;
 413   if (p != NULL) {
 414     for (int i = 0; i < p->length(); i++) {
 415       bytes += count_bytes_array(p->at(i));
 416     }
 417     bytes += count_bytes_array(p);
 418   }
 419   return bytes;
 420 }
 421 
 422 void KlassInfoHisto::print_histo_on(outputStream* st, bool print_stats,
 423                                     bool csv_format, const char *columns) {
 424   if (print_stats) {
 425     print_class_stats(st, csv_format, columns);
 426   } else {
 427     st->print_cr("%s",title());
 428     print_elements(st);
 429   }
 430 }
 431 
 432 class HistoClosure : public KlassInfoClosure {
 433  private:
 434   KlassInfoHisto* _cih;
 435  public:
 436   HistoClosure(KlassInfoHisto* cih) : _cih(cih) {}
 437 
 438   void do_cinfo(KlassInfoEntry* cie) {
 439     _cih->add(cie);
 440   }
 441 };
 442 
 443 class RecordInstanceClosure : public ObjectClosure {
 444  private:
 445   KlassInfoTable* _cit;
 446   size_t _missed_count;
 447  public:
 448   RecordInstanceClosure(KlassInfoTable* cit) :
 449     _cit(cit), _missed_count(0) {}
 450 
 451   void do_object(oop obj) {
 452     if (!_cit->record_instance(obj)) {
 453       _missed_count++;
 454     }
 455   }
 456 
 457   size_t missed_count() { return _missed_count; }
 458 };
 459 
 460 void HeapInspection::heap_inspection(outputStream* st, bool need_prologue) {
 461   ResourceMark rm;
 462   // Get some random number for ref (the hash key)
 463   HeapWord* ref = (HeapWord*) Universe::boolArrayKlassObj();
 464   CollectedHeap* heap = Universe::heap();
 465   bool is_shared_heap = false;
 466 
 467   if (_print_help) {
 468     for (int c=0; c<KlassSizeStats::_num_columns; c++) {
 469       st->print("%s:\n\t", name_table[c]);
 470       const int max_col = 60;
 471       int col = 0;
 472       for (const char *p = help_table[c]; *p; p++,col++) {
 473         if (col >= max_col && *p == ' ') {
 474           st->print("\n\t");
 475           col = 0;
 476         } else {
 477           st->print("%c", *p);
 478         }
 479       }
 480       st->print_cr(".\n");
 481     }
 482     return;
 483   }
 484 
 485   // Collect klass instance info
 486   KlassInfoTable cit(KlassInfoTable::cit_size, ref, _print_class_stats);
 487   if (!cit.allocation_failed()) {
 488     // Iterate over objects in the heap
 489     RecordInstanceClosure ric(&cit);
 490     Universe::heap()->object_iterate(&ric);
 491 
 492     // Report if certain classes are not counted because of
 493     // running out of C-heap for the histogram.
 494     size_t missed_count = ric.missed_count();
 495     if (missed_count != 0) {
 496       st->print_cr("WARNING: Ran out of C-heap; undercounted " SIZE_FORMAT
 497                    " total instances in data below",
 498                    missed_count);
 499     }
 500     // Sort and print klass instance info
 501     const char *title = "\n"
 502               " num     #instances         #bytes  class name\n"
 503               "----------------------------------------------";
 504     KlassInfoHisto histo(&cit, title, KlassInfoHisto::histo_initial_size);
 505     HistoClosure hc(&histo);
 506     cit.iterate(&hc);
 507     histo.sort();
 508     histo.print_histo_on(st, _print_class_stats, _csv_format, _columns);
 509   } else {
 510     st->print_cr("WARNING: Ran out of C-heap; histogram not generated");
 511   }
 512   st->flush();
 513 
 514   if (need_prologue && is_shared_heap) {
 515     SharedHeap* sh = (SharedHeap*)heap;
 516     sh->gc_epilogue(false /* !full */); // release all acquired locks, etc.
 517   }
 518 }
 519 
 520 class FindInstanceClosure : public ObjectClosure {
 521  private:
 522   Klass* _klass;
 523   GrowableArray<oop>* _result;
 524 
 525  public:
 526   FindInstanceClosure(Klass* k, GrowableArray<oop>* result) : _klass(k), _result(result) {};
 527 
 528   void do_object(oop obj) {
 529     if (obj->is_a(_klass)) {
 530       _result->append(obj);
 531     }
 532   }
 533 };
 534 
 535 void HeapInspection::find_instances_at_safepoint(Klass* k, GrowableArray<oop>* result) {
 536   assert(SafepointSynchronize::is_at_safepoint(), "all threads are stopped");
 537   assert(Heap_lock->is_locked(), "should have the Heap_lock");
 538 
 539   // Ensure that the heap is parsable
 540   Universe::heap()->ensure_parsability(false);  // no need to retire TALBs
 541 
 542   // Iterate over objects in the heap
 543   FindInstanceClosure fic(k, result);
 544   // If this operation encounters a bad object when using CMS,
 545   // consider using safe_object_iterate() which avoids metadata
 546   // objects that may contain bad references.
 547   Universe::heap()->object_iterate(&fic);
 548 }