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 (std::nothrow) 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(bool need_class_stats) {
 131   _size_of_instances_in_words = 0;
 132   _size = 0;
 133   _ref = (HeapWord*) Universe::boolArrayKlassObj();
 134   _buckets =
 135     (KlassInfoBucket*)  AllocateHeap(sizeof(KlassInfoBucket) * _num_buckets,
 136                                             mtInternal, 0, AllocFailStrategy::RETURN_NULL);
 137   if (_buckets != NULL) {
 138     _size = _num_buckets;
 139     for (int index = 0; index < _size; index++) {
 140       _buckets[index].initialize();
 141     }
 142     if (need_class_stats) {
 143       AllClassesFinder finder(this);
 144       ClassLoaderDataGraph::classes_do(&finder);
 145     }
 146   }
 147 }
 148 
 149 KlassInfoTable::~KlassInfoTable() {
 150   if (_buckets != NULL) {
 151     for (int index = 0; index < _size; index++) {
 152       _buckets[index].empty();
 153     }
 154     FREE_C_HEAP_ARRAY(KlassInfoBucket, _buckets, mtInternal);
 155     _size = 0;
 156   }
 157 }
 158 
 159 uint KlassInfoTable::hash(const Klass* p) {
 160   assert(p->is_metadata(), "all klasses are metadata");
 161   return (uint)(((uintptr_t)p - (uintptr_t)_ref) >> 2);
 162 }
 163 
 164 KlassInfoEntry* KlassInfoTable::lookup(Klass* k) {
 165   uint         idx = hash(k) % _size;
 166   assert(_buckets != NULL, "Allocation failure should have been caught");
 167   KlassInfoEntry*  e   = _buckets[idx].lookup(k);
 168   // Lookup may fail if this is a new klass for which we
 169   // could not allocate space for an new entry.
 170   assert(e == NULL || k == e->klass(), "must be equal");
 171   return e;
 172 }
 173 
 174 // Return false if the entry could not be recorded on account
 175 // of running out of space required to create a new entry.
 176 bool KlassInfoTable::record_instance(const oop obj) {
 177   Klass*        k = obj->klass();
 178   KlassInfoEntry* elt = lookup(k);
 179   // elt may be NULL if it's a new klass for which we
 180   // could not allocate space for a new entry in the hashtable.
 181   if (elt != NULL) {
 182     elt->set_count(elt->count() + 1);
 183     elt->set_words(elt->words() + obj->size());
 184     _size_of_instances_in_words += obj->size();
 185     return true;
 186   } else {
 187     return false;
 188   }
 189 }
 190 
 191 void KlassInfoTable::iterate(KlassInfoClosure* cic) {
 192   assert(_size == 0 || _buckets != NULL, "Allocation failure should have been caught");
 193   for (int index = 0; index < _size; index++) {
 194     _buckets[index].iterate(cic);
 195   }
 196 }
 197 
 198 size_t KlassInfoTable::size_of_instances_in_words() const {
 199   return _size_of_instances_in_words;
 200 }
 201 
 202 int KlassInfoHisto::sort_helper(KlassInfoEntry** e1, KlassInfoEntry** e2) {
 203   return (*e1)->compare(*e1,*e2);
 204 }
 205 
 206 KlassInfoHisto::KlassInfoHisto(KlassInfoTable* cit, const char* title) :
 207   _cit(cit),
 208   _title(title) {
 209   _elements = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<KlassInfoEntry*>(_histo_initial_size, true);
 210 }
 211 
 212 KlassInfoHisto::~KlassInfoHisto() {
 213   delete _elements;
 214 }
 215 
 216 void KlassInfoHisto::add(KlassInfoEntry* cie) {
 217   elements()->append(cie);
 218 }
 219 
 220 void KlassInfoHisto::sort() {
 221   elements()->sort(KlassInfoHisto::sort_helper);
 222 }
 223 
 224 void KlassInfoHisto::print_elements(outputStream* st) const {
 225   // simplify the formatting (ILP32 vs LP64) - store the sum in 64-bit
 226   jlong total = 0;
 227   julong totalw = 0;
 228   for(int i=0; i < elements()->length(); i++) {
 229     st->print("%4d: ", i+1);
 230     elements()->at(i)->print_on(st);
 231     total += elements()->at(i)->count();
 232     totalw += elements()->at(i)->words();
 233   }
 234   st->print_cr("Total " INT64_FORMAT_W(13) "  " UINT64_FORMAT_W(13),
 235                total, totalw * HeapWordSize);
 236 }
 237 
 238 #define MAKE_COL_NAME(field, name, help)     #name,
 239 #define MAKE_COL_HELP(field, name, help)     help,
 240 
 241 static const char *name_table[] = {
 242   HEAP_INSPECTION_COLUMNS_DO(MAKE_COL_NAME)
 243 };
 244 
 245 static const char *help_table[] = {
 246   HEAP_INSPECTION_COLUMNS_DO(MAKE_COL_HELP)
 247 };
 248 
 249 bool KlassInfoHisto::is_selected(const char *col_name) {
 250   if (_selected_columns == NULL) {
 251     return true;
 252   }
 253   if (strcmp(_selected_columns, col_name) == 0) {
 254     return true;
 255   }
 256 
 257   const char *start = strstr(_selected_columns, col_name);
 258   if (start == NULL) {
 259     return false;
 260   }
 261 
 262   // The following must be true, because _selected_columns != col_name
 263   if (start > _selected_columns && start[-1] != ',') {
 264     return false;
 265   }
 266   char x = start[strlen(col_name)];
 267   if (x != ',' && x != '\0') {
 268     return false;
 269   }
 270 
 271   return true;
 272 }
 273 
 274 void KlassInfoHisto::print_title(outputStream* st, bool csv_format,
 275                                  bool selected[], int width_table[],
 276                                  const char *name_table[]) {
 277   if (csv_format) {
 278     st->print("Index,Super");
 279     for (int c=0; c<KlassSizeStats::_num_columns; c++) {
 280        if (selected[c]) {st->print(",%s", name_table[c]);}
 281     }
 282     st->print(",ClassName");
 283   } else {
 284     st->print("Index Super");
 285     for (int c=0; c<KlassSizeStats::_num_columns; c++) {
 286       if (selected[c]) {st->print(str_fmt(width_table[c]), name_table[c]);}
 287     }
 288     st->print(" ClassName");
 289   }
 290 
 291   if (is_selected("ClassLoader")) {
 292     st->print(",ClassLoader");
 293   }
 294   st->cr();
 295 }
 296 
 297 void KlassInfoHisto::print_class_stats(outputStream* st,
 298                                       bool csv_format, const char *columns) {
 299   ResourceMark rm;
 300   KlassSizeStats sz, sz_sum;
 301   int i;
 302   julong *col_table = (julong*)(&sz);
 303   julong *colsum_table = (julong*)(&sz_sum);
 304   int width_table[KlassSizeStats::_num_columns];
 305   bool selected[KlassSizeStats::_num_columns];
 306 
 307   _selected_columns = columns;
 308 
 309   memset(&sz_sum, 0, sizeof(sz_sum));
 310   for (int c=0; c<KlassSizeStats::_num_columns; c++) {
 311     selected[c] = is_selected(name_table[c]);
 312   }
 313 
 314   for(i=0; i < elements()->length(); i++) {
 315     elements()->at(i)->set_index(i+1);
 316   }
 317 
 318   for (int pass=1; pass<=2; pass++) {
 319     if (pass == 2) {
 320       print_title(st, csv_format, selected, width_table, name_table);
 321     }
 322     for(i=0; i < elements()->length(); i++) {
 323       KlassInfoEntry* e = (KlassInfoEntry*)elements()->at(i);
 324       const Klass* k = e->klass();
 325 
 326       memset(&sz, 0, sizeof(sz));
 327       sz._inst_count = e->count();
 328       sz._inst_bytes = HeapWordSize * e->words();
 329       k->collect_statistics(&sz);
 330       sz._total_bytes = sz._ro_bytes + sz._rw_bytes;
 331 
 332       if (pass == 1) {
 333         for (int c=0; c<KlassSizeStats::_num_columns; c++) {
 334           colsum_table[c] += col_table[c];
 335         }
 336       } else {
 337         int super_index = -1;
 338         if (k->oop_is_instance()) {
 339           Klass* super = ((InstanceKlass*)k)->java_super();
 340           if (super) {
 341             KlassInfoEntry* super_e = _cit->lookup(super);
 342             if (super_e) {
 343               super_index = super_e->index();
 344             }
 345           }
 346         }
 347 
 348         if (csv_format) {
 349           st->print("%d,%d", e->index(), super_index);
 350           for (int c=0; c<KlassSizeStats::_num_columns; c++) {
 351             if (selected[c]) {st->print("," JULONG_FORMAT, col_table[c]);}
 352           }
 353           st->print(",%s",e->name());
 354         } else {
 355           st->print("%5d %5d", e->index(), super_index);
 356           for (int c=0; c<KlassSizeStats::_num_columns; c++) {
 357             if (selected[c]) {print_julong(st, width_table[c], col_table[c]);}
 358           }
 359           st->print(" %s", e->name());
 360         }
 361         if (is_selected("ClassLoader")) {
 362           ClassLoaderData* loader_data = k->class_loader_data();
 363           st->print(",");
 364           loader_data->print_value_on(st);
 365         }
 366         st->cr();
 367       }
 368     }
 369 
 370     if (pass == 1) {
 371       for (int c=0; c<KlassSizeStats::_num_columns; c++) {
 372         width_table[c] = col_width(colsum_table[c], name_table[c]);
 373       }
 374     }
 375   }
 376 
 377   sz_sum._inst_size = 0;
 378 
 379   if (csv_format) {
 380     st->print(",");
 381     for (int c=0; c<KlassSizeStats::_num_columns; c++) {
 382       if (selected[c]) {st->print("," JULONG_FORMAT, colsum_table[c]);}
 383     }
 384   } else {
 385     st->print("           ");
 386     for (int c=0; c<KlassSizeStats::_num_columns; c++) {
 387       if (selected[c]) {print_julong(st, width_table[c], colsum_table[c]);}
 388     }
 389     st->print(" Total");
 390     if (sz_sum._total_bytes > 0) {
 391       st->cr();
 392       st->print("           ");
 393       for (int c=0; c<KlassSizeStats::_num_columns; c++) {
 394         if (selected[c]) {
 395           switch (c) {
 396           case KlassSizeStats::_index_inst_size:
 397           case KlassSizeStats::_index_inst_count:
 398           case KlassSizeStats::_index_method_count:
 399             st->print(str_fmt(width_table[c]), "-");
 400             break;
 401           default:
 402             {
 403               double perc = (double)(100) * (double)(colsum_table[c]) / (double)sz_sum._total_bytes;
 404               st->print(perc_fmt(width_table[c]), perc);
 405             }
 406           }
 407         }
 408       }
 409     }
 410   }
 411   st->cr();
 412 
 413   if (!csv_format) {
 414     print_title(st, csv_format, selected, width_table, name_table);
 415   }
 416 }
 417 
 418 julong KlassInfoHisto::annotations_bytes(Array<AnnotationArray*>* p) const {
 419   julong bytes = 0;
 420   if (p != NULL) {
 421     for (int i = 0; i < p->length(); i++) {
 422       bytes += count_bytes_array(p->at(i));
 423     }
 424     bytes += count_bytes_array(p);
 425   }
 426   return bytes;
 427 }
 428 
 429 void KlassInfoHisto::print_histo_on(outputStream* st, bool print_stats,
 430                                     bool csv_format, const char *columns) {
 431   if (print_stats) {
 432     print_class_stats(st, csv_format, columns);
 433   } else {
 434     st->print_cr("%s",title());
 435     print_elements(st);
 436   }
 437 }
 438 
 439 class HistoClosure : public KlassInfoClosure {
 440  private:
 441   KlassInfoHisto* _cih;
 442  public:
 443   HistoClosure(KlassInfoHisto* cih) : _cih(cih) {}
 444 
 445   void do_cinfo(KlassInfoEntry* cie) {
 446     _cih->add(cie);
 447   }
 448 };
 449 
 450 class RecordInstanceClosure : public ObjectClosure {
 451  private:
 452   KlassInfoTable* _cit;
 453   size_t _missed_count;
 454   BoolObjectClosure* _filter;
 455  public:
 456   RecordInstanceClosure(KlassInfoTable* cit, BoolObjectClosure* filter) :
 457     _cit(cit), _missed_count(0), _filter(filter) {}
 458 
 459   void do_object(oop obj) {
 460     if (should_visit(obj)) {
 461       if (!_cit->record_instance(obj)) {
 462         _missed_count++;
 463       }
 464     }
 465   }
 466 
 467   size_t missed_count() { return _missed_count; }
 468 
 469  private:
 470   bool should_visit(oop obj) {
 471     return _filter == NULL || _filter->do_object_b(obj);
 472   }
 473 };
 474 
 475 size_t HeapInspection::populate_table(KlassInfoTable* cit, BoolObjectClosure *filter) {
 476   ResourceMark rm;
 477 
 478   RecordInstanceClosure ric(cit, filter);
 479   Universe::heap()->object_iterate(&ric);
 480   return ric.missed_count();
 481 }
 482 
 483 void HeapInspection::heap_inspection(outputStream* st) {
 484   ResourceMark rm;
 485 
 486   if (_print_help) {
 487     for (int c=0; c<KlassSizeStats::_num_columns; c++) {
 488       st->print("%s:\n\t", name_table[c]);
 489       const int max_col = 60;
 490       int col = 0;
 491       for (const char *p = help_table[c]; *p; p++,col++) {
 492         if (col >= max_col && *p == ' ') {
 493           st->print("\n\t");
 494           col = 0;
 495         } else {
 496           st->print("%c", *p);
 497         }
 498       }
 499       st->print_cr(".\n");
 500     }
 501     return;
 502   }
 503 
 504   KlassInfoTable cit(_print_class_stats);
 505   if (!cit.allocation_failed()) {
 506     size_t missed_count = populate_table(&cit);
 507     if (missed_count != 0) {
 508       st->print_cr("WARNING: Ran out of C-heap; undercounted " SIZE_FORMAT
 509                    " total instances in data below",
 510                    missed_count);
 511     }
 512 
 513     // Sort and print klass instance info
 514     const char *title = "\n"
 515               " num     #instances         #bytes  class name\n"
 516               "----------------------------------------------";
 517     KlassInfoHisto histo(&cit, title);
 518     HistoClosure hc(&histo);
 519 
 520     cit.iterate(&hc);
 521 
 522     histo.sort();
 523     histo.print_histo_on(st, _print_class_stats, _csv_format, _columns);
 524   } else {
 525     st->print_cr("WARNING: Ran out of C-heap; histogram not generated");
 526   }
 527   st->flush();
 528 }
 529 
 530 class FindInstanceClosure : public ObjectClosure {
 531  private:
 532   Klass* _klass;
 533   GrowableArray<oop>* _result;
 534 
 535  public:
 536   FindInstanceClosure(Klass* k, GrowableArray<oop>* result) : _klass(k), _result(result) {};
 537 
 538   void do_object(oop obj) {
 539     if (obj->is_a(_klass)) {
 540       _result->append(obj);
 541     }
 542   }
 543 };
 544 
 545 void HeapInspection::find_instances_at_safepoint(Klass* k, GrowableArray<oop>* result) {
 546   assert(SafepointSynchronize::is_at_safepoint(), "all threads are stopped");
 547   assert(Heap_lock->is_locked(), "should have the Heap_lock");
 548 
 549   // Ensure that the heap is parsable
 550   Universe::heap()->ensure_parsability(false);  // no need to retire TALBs
 551 
 552   // Iterate over objects in the heap
 553   FindInstanceClosure fic(k, result);
 554   // If this operation encounters a bad object when using CMS,
 555   // consider using safe_object_iterate() which avoids metadata
 556   // objects that may contain bad references.
 557   Universe::heap()->object_iterate(&fic);
 558 }