1 /*

     2  * Copyright (c) 2002, 2016, 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 "classfile/moduleEntry.hpp"

    28 #include "classfile/systemDictionary.hpp"

    29 #include "gc/shared/collectedHeap.hpp"

    30 #include "gc/shared/genCollectedHeap.hpp"

    31 #include "memory/heapInspection.hpp"

    32 #include "memory/resourceArea.hpp"

    33 #include "oops/oop.inline.hpp"

    34 #include "runtime/os.hpp"

    35 #include "utilities/globalDefinitions.hpp"

    36 #include "utilities/macros.hpp"

    37 #include "utilities/stack.inline.hpp"

    38 #if INCLUDE_ALL_GCS

    39 #include "gc/parallel/parallelScavengeHeap.hpp"

    40 #endif // INCLUDE_ALL_GCS

    41 

    42 // HeapInspection

    43 

    44 int KlassSizeStats::count(oop x) {

    45   return (HeapWordSize * (((x) != NULL) ? (x)->size() : 0));

    46 }

    47 

    48 int KlassSizeStats::count_array(objArrayOop x) {

    49   return (HeapWordSize * (((x) != NULL) ? (x)->size() : 0));

    50 }

    51 

    52 inline KlassInfoEntry::~KlassInfoEntry() {

    53   if (_subclasses != NULL) {

    54     delete _subclasses;

    55   }

    56 }

    57 

    58 inline void KlassInfoEntry::add_subclass(KlassInfoEntry* cie) {

    59   if (_subclasses == NULL) {

    60     _subclasses = new  (ResourceObj::C_HEAP, mtInternal) GrowableArray<KlassInfoEntry*>(4, true);

    61   }

    62   _subclasses->append(cie);

    63 }

    64 

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

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

    67     return -1;

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

    69     return 1;

    70   }

    71   // Sort alphabetically, note 'Z' < '[' < 'a', but it's better to group

    72   // the array classes before all the instance classes.

    73   ResourceMark rm;

    74   const char* name1 = e1->klass()->external_name();

    75   const char* name2 = e2->klass()->external_name();

    76   bool d1 = (name1[0] == '[');

    77   bool d2 = (name2[0] == '[');

    78   if (d1 && !d2) {

    79     return -1;

    80   } else if (d2 && !d1) {

    81     return 1;

    82   } else {

    83     return strcmp(name1, name2);

    84   }

    85 }

    86 

    87 const char* KlassInfoEntry::name() const {

    88   const char* name;

    89   if (_klass->name() != NULL) {

    90     name = _klass->external_name();

    91   } else {

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

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

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

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

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

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

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

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

   100       name = "<no name>";

   101   }

   102   return name;

   103 }

   104 

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

   106   ResourceMark rm;

   107 

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

   109   ModuleEntry* module = _klass->module();

   110   if (module->is_named()) {

   111     st->print_cr(INT64_FORMAT_W(13) "  " UINT64_FORMAT_W(13) "  %s (%s@%s)",

   112                  (int64_t)_instance_count,

   113                  (uint64_t)_instance_words * HeapWordSize,

   114                  name(),

   115                  module->name()->as_C_string(),

   116                  module->version() != NULL ? module->version()->as_C_string() : "");

   117   } else {

   118     st->print_cr(INT64_FORMAT_W(13) "  " UINT64_FORMAT_W(13) "  %s",

   119                  (int64_t)_instance_count,

   120                  (uint64_t)_instance_words * HeapWordSize,

   121                  name());

   122   }

   123 }

   124 

   125 KlassInfoEntry* KlassInfoBucket::lookup(Klass* const k) {

   126   KlassInfoEntry* elt = _list;

   127   while (elt != NULL) {

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

   129       return elt;

   130     }

   131     elt = elt->next();

   132   }

   133   elt = new (std::nothrow) KlassInfoEntry(k, list());

   134   // We may be out of space to allocate the new entry.

   135   if (elt != NULL) {

   136     set_list(elt);

   137   }

   138   return elt;

   139 }

   140 

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

   142   KlassInfoEntry* elt = _list;

   143   while (elt != NULL) {

   144     cic->do_cinfo(elt);

   145     elt = elt->next();

   146   }

   147 }

   148 

   149 void KlassInfoBucket::empty() {

   150   KlassInfoEntry* elt = _list;

   151   _list = NULL;

   152   while (elt != NULL) {

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

   154     delete elt;

   155     elt = next;

   156   }

   157 }

   158 

   159 void KlassInfoTable::AllClassesFinder::do_klass(Klass* k) {

   160   // This has the SIDE EFFECT of creating a KlassInfoEntry

   161   // for <k>, if one doesn't exist yet.

   162   _table->lookup(k);

   163 }

   164 

   165 KlassInfoTable::KlassInfoTable(bool add_all_classes) {

   166   _size_of_instances_in_words = 0;

   167   _size = 0;

   168   _ref = (HeapWord*) Universe::boolArrayKlassObj();

   169   _buckets =

   170     (KlassInfoBucket*)  AllocateHeap(sizeof(KlassInfoBucket) * _num_buckets,

   171        mtInternal, CURRENT_PC, AllocFailStrategy::RETURN_NULL);

   172   if (_buckets != NULL) {

   173     _size = _num_buckets;

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

   175       _buckets[index].initialize();

   176     }

   177     if (add_all_classes) {

   178       AllClassesFinder finder(this);

   179       ClassLoaderDataGraph::classes_do(&finder);

   180     }

   181   }

   182 }

   183 

   184 KlassInfoTable::~KlassInfoTable() {

   185   if (_buckets != NULL) {

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

   187       _buckets[index].empty();

   188     }

   189     FREE_C_HEAP_ARRAY(KlassInfoBucket, _buckets);

   190     _size = 0;

   191   }

   192 }

   193 

   194 uint KlassInfoTable::hash(const Klass* p) {

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

   196 }

   197 

   198 KlassInfoEntry* KlassInfoTable::lookup(Klass* k) {

   199   uint         idx = hash(k) % _size;

   200   assert(_buckets != NULL, "Allocation failure should have been caught");

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

   202   // Lookup may fail if this is a new klass for which we

   203   // could not allocate space for an new entry.

   204   assert(e == NULL || k == e->klass(), "must be equal");

   205   return e;

   206 }

   207 

   208 // Return false if the entry could not be recorded on account

   209 // of running out of space required to create a new entry.

   210 bool KlassInfoTable::record_instance(const oop obj) {

   211   Klass*        k = obj->klass();

   212   KlassInfoEntry* elt = lookup(k);

   213   // elt may be NULL if it's a new klass for which we

   214   // could not allocate space for a new entry in the hashtable.

   215   if (elt != NULL) {

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

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

   218     _size_of_instances_in_words += obj->size();

   219     return true;

   220   } else {

   221     return false;

   222   }

   223 }

   224 

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

   226   assert(_size == 0 || _buckets != NULL, "Allocation failure should have been caught");

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

   228     _buckets[index].iterate(cic);

   229   }

   230 }

   231 

   232 size_t KlassInfoTable::size_of_instances_in_words() const {

   233   return _size_of_instances_in_words;

   234 }

   235 

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

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

   238 }

   239 

   240 KlassInfoHisto::KlassInfoHisto(KlassInfoTable* cit) :

   241   _cit(cit) {

   242   _elements = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<KlassInfoEntry*>(_histo_initial_size, true);

   243 }

   244 

   245 KlassInfoHisto::~KlassInfoHisto() {

   246   delete _elements;

   247 }

   248 

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

   250   elements()->append(cie);

   251 }

   252 

   253 void KlassInfoHisto::sort() {

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

   255 }

   256 

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

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

   259   int64_t total = 0;

   260   uint64_t totalw = 0;

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

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

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

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

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

   266   }

   267   st->print_cr("Total " INT64_FORMAT_W(13) "  " UINT64_FORMAT_W(13),

   268                total, totalw * HeapWordSize);

   269 }

   270 

   271 #define MAKE_COL_NAME(field, name, help)     #name,

   272 #define MAKE_COL_HELP(field, name, help)     help,

   273 

   274 static const char *name_table[] = {

   275   HEAP_INSPECTION_COLUMNS_DO(MAKE_COL_NAME)

   276 };

   277 

   278 static const char *help_table[] = {

   279   HEAP_INSPECTION_COLUMNS_DO(MAKE_COL_HELP)

   280 };

   281 

   282 bool KlassInfoHisto::is_selected(const char *col_name) {

   283   if (_selected_columns == NULL) {

   284     return true;

   285   }

   286   if (strcmp(_selected_columns, col_name) == 0) {

   287     return true;

   288   }

   289 

   290   const char *start = strstr(_selected_columns, col_name);

   291   if (start == NULL) {

   292     return false;

   293   }

   294 

   295   // The following must be true, because _selected_columns != col_name

   296   if (start > _selected_columns && start[-1] != ',') {

   297     return false;

   298   }

   299   char x = start[strlen(col_name)];

   300   if (x != ',' && x != '\0') {

   301     return false;

   302   }

   303 

   304   return true;

   305 }

   306 

   307 void KlassInfoHisto::print_title(outputStream* st, bool csv_format,

   308                                  bool selected[], int width_table[],

   309                                  const char *name_table[]) {

   310   if (csv_format) {

   311     st->print("Index,Super");

   312     for (int c=0; c<KlassSizeStats::_num_columns; c++) {

   313        if (selected[c]) {st->print(",%s", name_table[c]);}

   314     }

   315     st->print(",ClassName");

   316   } else {

   317     st->print("Index Super");

   318     for (int c = 0; c < KlassSizeStats::_num_columns; c++) {

   319       if (selected[c]) {

   320         st->print("%*s", width_table[c], name_table[c]);

   321       }

   322     }

   323     st->print(" ClassName");

   324   }

   325 

   326   if (is_selected("ClassLoader")) {

   327     st->print(",ClassLoader");

   328   }

   329   st->cr();

   330 }

   331 

   332 class HierarchyClosure : public KlassInfoClosure {

   333 private:

   334   GrowableArray<KlassInfoEntry*> *_elements;

   335 public:

   336   HierarchyClosure(GrowableArray<KlassInfoEntry*> *_elements) : _elements(_elements) {}

   337 

   338   void do_cinfo(KlassInfoEntry* cie) {

   339     // ignore array classes

   340     if (cie->klass()->is_instance_klass()) {

   341       _elements->append(cie);

   342     }

   343   }

   344 };

   345 

   346 void KlassHierarchy::print_class_hierarchy(outputStream* st, bool print_interfaces,

   347                                            bool print_subclasses, char* classname) {

   348   ResourceMark rm;

   349   Stack <KlassInfoEntry*, mtClass> class_stack;

   350   GrowableArray<KlassInfoEntry*> elements;

   351 

   352   // Add all classes to the KlassInfoTable, which allows for quick lookup.

   353   // A KlassInfoEntry will be created for each class.

   354   KlassInfoTable cit(true);

   355   if (cit.allocation_failed()) {

   356     st->print_cr("ERROR: Ran out of C-heap; hierarchy not generated");

   357     return;

   358   }

   359 

   360   // Add all created KlassInfoEntry instances to the elements array for easy

   361   // iteration, and to allow each KlassInfoEntry instance to have a unique index.

   362   HierarchyClosure hc(&elements);

   363   cit.iterate(&hc);

   364 

   365   for(int i = 0; i < elements.length(); i++) {

   366     KlassInfoEntry* cie = elements.at(i);

   367     Klass* super = cie->klass()->super();

   368 

   369     // Set the index for the class.

   370     cie->set_index(i + 1);

   371 

   372     // Add the class to the subclass array of its superclass.

   373     if (super != NULL) {

   374       KlassInfoEntry* super_cie = cit.lookup(super);

   375       assert(super_cie != NULL, "could not lookup superclass");

   376       super_cie->add_subclass(cie);

   377     }

   378   }

   379 

   380   // Set the do_print flag for each class that should be printed.

   381   for(int i = 0; i < elements.length(); i++) {

   382     KlassInfoEntry* cie = elements.at(i);

   383     if (classname == NULL) {

   384       // We are printing all classes.

   385       cie->set_do_print(true);

   386     } else {

   387       // We are only printing the hierarchy of a specific class.

   388       if (strcmp(classname, cie->klass()->external_name()) == 0) {

   389         KlassHierarchy::set_do_print_for_class_hierarchy(cie, &cit, print_subclasses);

   390       }

   391     }

   392   }

   393 

   394   // Now we do a depth first traversal of the class hierachry. The class_stack will

   395   // maintain the list of classes we still need to process. Start things off

   396   // by priming it with java.lang.Object.

   397   KlassInfoEntry* jlo_cie = cit.lookup(SystemDictionary::Object_klass());

   398   assert(jlo_cie != NULL, "could not lookup java.lang.Object");

   399   class_stack.push(jlo_cie);

   400 

   401   // Repeatedly pop the top item off the stack, print its class info,

   402   // and push all of its subclasses on to the stack. Do this until there

   403   // are no classes left on the stack.

   404   while (!class_stack.is_empty()) {

   405     KlassInfoEntry* curr_cie = class_stack.pop();

   406     if (curr_cie->do_print()) {

   407       print_class(st, curr_cie, print_interfaces);

   408       if (curr_cie->subclasses() != NULL) {

   409         // Current class has subclasses, so push all of them onto the stack.

   410         for (int i = 0; i < curr_cie->subclasses()->length(); i++) {

   411           KlassInfoEntry* cie = curr_cie->subclasses()->at(i);

   412           if (cie->do_print()) {

   413             class_stack.push(cie);

   414           }

   415         }

   416       }

   417     }

   418   }

   419 

   420   st->flush();

   421 }

   422 

   423 // Sets the do_print flag for every superclass and subclass of the specified class.

   424 void KlassHierarchy::set_do_print_for_class_hierarchy(KlassInfoEntry* cie, KlassInfoTable* cit,

   425                                                       bool print_subclasses) {

   426   // Set do_print for all superclasses of this class.

   427   Klass* super = ((InstanceKlass*)cie->klass())->java_super();

   428   while (super != NULL) {

   429     KlassInfoEntry* super_cie = cit->lookup(super);

   430     super_cie->set_do_print(true);

   431     super = super->super();

   432   }

   433 

   434   // Set do_print for this class and all of its subclasses.

   435   Stack <KlassInfoEntry*, mtClass> class_stack;

   436   class_stack.push(cie);

   437   while (!class_stack.is_empty()) {

   438     KlassInfoEntry* curr_cie = class_stack.pop();

   439     curr_cie->set_do_print(true);

   440     if (print_subclasses && curr_cie->subclasses() != NULL) {

   441       // Current class has subclasses, so push all of them onto the stack.

   442       for (int i = 0; i < curr_cie->subclasses()->length(); i++) {

   443         KlassInfoEntry* cie = curr_cie->subclasses()->at(i);

   444         class_stack.push(cie);

   445       }

   446     }

   447   }

   448 }

   449 

   450 static void print_indent(outputStream* st, int indent) {

   451   while (indent != 0) {

   452     st->print("|");

   453     indent--;

   454     if (indent != 0) {

   455       st->print("  ");

   456     }

   457   }

   458 }

   459 

   460 // Print the class name and its unique ClassLoader identifer.

   461 static void print_classname(outputStream* st, Klass* klass) {

   462   oop loader_oop = klass->class_loader_data()->class_loader();

   463   st->print("%s/", klass->external_name());

   464   if (loader_oop == NULL) {

   465     st->print("null");

   466   } else {

   467     st->print(INTPTR_FORMAT, p2i(klass->class_loader_data()));

   468   }

   469 }

   470 

   471 static void print_interface(outputStream* st, Klass* intf_klass, const char* intf_type, int indent) {

   472   print_indent(st, indent);

   473   st->print("  implements ");

   474   print_classname(st, intf_klass);

   475   st->print(" (%s intf)\n", intf_type);

   476 }

   477 

   478 void KlassHierarchy::print_class(outputStream* st, KlassInfoEntry* cie, bool print_interfaces) {

   479   ResourceMark rm;

   480   InstanceKlass* klass = (InstanceKlass*)cie->klass();

   481   int indent = 0;

   482 

   483   // Print indentation with proper indicators of superclass.

   484   Klass* super = klass->super();

   485   while (super != NULL) {

   486     super = super->super();

   487     indent++;

   488   }

   489   print_indent(st, indent);

   490   if (indent != 0) st->print("--");

   491 

   492   // Print the class name, its unique ClassLoader identifer, and if it is an interface.

   493   print_classname(st, klass);

   494   if (klass->is_interface()) {

   495     st->print(" (intf)");

   496   }

   497   st->print("\n");

   498 

   499   // Print any interfaces the class has.

   500   if (print_interfaces) {

   501     Array<Klass*>* local_intfs = klass->local_interfaces();

   502     Array<Klass*>* trans_intfs = klass->transitive_interfaces();

   503     for (int i = 0; i < local_intfs->length(); i++) {

   504       print_interface(st, local_intfs->at(i), "declared", indent);

   505     }

   506     for (int i = 0; i < trans_intfs->length(); i++) {

   507       Klass* trans_interface = trans_intfs->at(i);

   508       // Only print transitive interfaces if they are not also declared.

   509       if (!local_intfs->contains(trans_interface)) {

   510         print_interface(st, trans_interface, "inherited", indent);

   511       }

   512     }

   513   }

   514 }

   515 

   516 void KlassInfoHisto::print_class_stats(outputStream* st,

   517                                       bool csv_format, const char *columns) {

   518   ResourceMark rm;

   519   KlassSizeStats sz, sz_sum;

   520   int i;

   521   julong *col_table = (julong*)(&sz);

   522   julong *colsum_table = (julong*)(&sz_sum);

   523   int width_table[KlassSizeStats::_num_columns];

   524   bool selected[KlassSizeStats::_num_columns];

   525 

   526   _selected_columns = columns;

   527 

   528   memset(&sz_sum, 0, sizeof(sz_sum));

   529   for (int c=0; c<KlassSizeStats::_num_columns; c++) {

   530     selected[c] = is_selected(name_table[c]);

   531   }

   532 

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

   534     elements()->at(i)->set_index(i+1);

   535   }

   536 

   537   // First iteration is for accumulating stats totals in colsum_table[].

   538   // Second iteration is for printing stats for each class.

   539   for (int pass=1; pass<=2; pass++) {

   540     if (pass == 2) {

   541       print_title(st, csv_format, selected, width_table, name_table);

   542     }

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

   544       KlassInfoEntry* e = (KlassInfoEntry*)elements()->at(i);

   545       const Klass* k = e->klass();

   546 

   547       // Get the stats for this class.

   548       memset(&sz, 0, sizeof(sz));

   549       sz._inst_count = e->count();

   550       sz._inst_bytes = HeapWordSize * e->words();

   551       k->collect_statistics(&sz);

   552       sz._total_bytes = sz._ro_bytes + sz._rw_bytes;

   553 

   554       if (pass == 1) {

   555         // Add the stats for this class to the overall totals.

   556         for (int c=0; c<KlassSizeStats::_num_columns; c++) {

   557           colsum_table[c] += col_table[c];

   558         }

   559       } else {

   560         int super_index = -1;

   561         // Print the stats for this class.

   562         if (k->is_instance_klass()) {

   563           Klass* super = k->super();

   564           if (super) {

   565             KlassInfoEntry* super_e = _cit->lookup(super);

   566             if (super_e) {

   567               super_index = super_e->index();

   568             }

   569           }

   570         }

   571 

   572         if (csv_format) {

   573           st->print("%ld,%d", e->index(), super_index);

   574           for (int c=0; c<KlassSizeStats::_num_columns; c++) {

   575             if (selected[c]) {st->print("," JULONG_FORMAT, col_table[c]);}

   576           }

   577           st->print(",%s",e->name());

   578         } else {

   579           st->print("%5ld %5d", e->index(), super_index);

   580           for (int c=0; c<KlassSizeStats::_num_columns; c++) {

   581             if (selected[c]) {print_julong(st, width_table[c], col_table[c]);}

   582           }

   583           st->print(" %s", e->name());

   584         }

   585         if (is_selected("ClassLoader")) {

   586           ClassLoaderData* loader_data = k->class_loader_data();

   587           st->print(",");

   588           loader_data->print_value_on(st);

   589         }

   590         st->cr();

   591       }

   592     }

   593 

   594     if (pass == 1) {

   595       // Calculate the minimum width needed for the column by accounting for the

   596       // column header width and the width of the largest value in the column.

   597       for (int c=0; c<KlassSizeStats::_num_columns; c++) {

   598         width_table[c] = col_width(colsum_table[c], name_table[c]);

   599       }

   600     }

   601   }

   602 

   603   sz_sum._inst_size = 0;

   604 

   605   // Print the column totals.

   606   if (csv_format) {

   607     st->print(",");

   608     for (int c=0; c<KlassSizeStats::_num_columns; c++) {

   609       if (selected[c]) {st->print("," JULONG_FORMAT, colsum_table[c]);}

   610     }

   611   } else {

   612     st->print("           ");

   613     for (int c=0; c<KlassSizeStats::_num_columns; c++) {

   614       if (selected[c]) {print_julong(st, width_table[c], colsum_table[c]);}

   615     }

   616     st->print(" Total");

   617     if (sz_sum._total_bytes > 0) {

   618       st->cr();

   619       st->print("           ");

   620       for (int c=0; c<KlassSizeStats::_num_columns; c++) {

   621         if (selected[c]) {

   622           switch (c) {

   623           case KlassSizeStats::_index_inst_size:

   624           case KlassSizeStats::_index_inst_count:

   625           case KlassSizeStats::_index_method_count:

   626             st->print("%*s", width_table[c], "-");

   627             break;

   628           default:

   629             {

   630               double perc = (double)(100) * (double)(colsum_table[c]) / (double)sz_sum._total_bytes;

   631               st->print("%*.1f%%", width_table[c]-1, perc);

   632             }

   633           }

   634         }

   635       }

   636     }

   637   }

   638   st->cr();

   639 

   640   if (!csv_format) {

   641     print_title(st, csv_format, selected, width_table, name_table);

   642   }

   643 }

   644 

   645 julong KlassInfoHisto::annotations_bytes(Array<AnnotationArray*>* p) const {

   646   julong bytes = 0;

   647   if (p != NULL) {

   648     for (int i = 0; i < p->length(); i++) {

   649       bytes += count_bytes_array(p->at(i));

   650     }

   651     bytes += count_bytes_array(p);

   652   }

   653   return bytes;

   654 }

   655 

   656 void KlassInfoHisto::print_histo_on(outputStream* st, bool print_stats,

   657                                     bool csv_format, const char *columns) {

   658   if (print_stats) {

   659     print_class_stats(st, csv_format, columns);

   660   } else {

   661     st->print_cr(" num     #instances         #bytes  class name (module)");

   662     st->print_cr("-------------------------------------------------------");

   663     print_elements(st);

   664   }

   665 }

   666 

   667 class HistoClosure : public KlassInfoClosure {

   668  private:

   669   KlassInfoHisto* _cih;

   670  public:

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

   672 

   673   void do_cinfo(KlassInfoEntry* cie) {

   674     _cih->add(cie);

   675   }

   676 };

   677 

   678 class RecordInstanceClosure : public ObjectClosure {

   679  private:

   680   KlassInfoTable* _cit;

   681   size_t _missed_count;

   682   BoolObjectClosure* _filter;

   683  public:

   684   RecordInstanceClosure(KlassInfoTable* cit, BoolObjectClosure* filter) :

   685     _cit(cit), _missed_count(0), _filter(filter) {}

   686 

   687   void do_object(oop obj) {

   688     if (should_visit(obj)) {

   689       if (!_cit->record_instance(obj)) {

   690         _missed_count++;

   691       }

   692     }

   693   }

   694 

   695   size_t missed_count() { return _missed_count; }

   696 

   697  private:

   698   bool should_visit(oop obj) {

   699     return _filter == NULL || _filter->do_object_b(obj);

   700   }

   701 };

   702 

   703 size_t HeapInspection::populate_table(KlassInfoTable* cit, BoolObjectClosure *filter) {

   704   ResourceMark rm;

   705 

   706   RecordInstanceClosure ric(cit, filter);

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

   708   return ric.missed_count();

   709 }

   710 

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

   712   ResourceMark rm;

   713 

   714   if (_print_help) {

   715     for (int c=0; c<KlassSizeStats::_num_columns; c++) {

   716       st->print("%s:\n\t", name_table[c]);

   717       const int max_col = 60;

   718       int col = 0;

   719       for (const char *p = help_table[c]; *p; p++,col++) {

   720         if (col >= max_col && *p == ' ') {

   721           st->print("\n\t");

   722           col = 0;

   723         } else {

   724           st->print("%c", *p);

   725         }

   726       }

   727       st->print_cr(".\n");

   728     }

   729     return;

   730   }

   731 

   732   KlassInfoTable cit(_print_class_stats);

   733   if (!cit.allocation_failed()) {

   734     // populate table with object allocation info

   735     size_t missed_count = populate_table(&cit);

   736     if (missed_count != 0) {

   737       st->print_cr("WARNING: Ran out of C-heap; undercounted " SIZE_FORMAT

   738                    " total instances in data below",

   739                    missed_count);

   740     }

   741 

   742     // Sort and print klass instance info

   743     KlassInfoHisto histo(&cit);

   744     HistoClosure hc(&histo);

   745 

   746     cit.iterate(&hc);

   747 

   748     histo.sort();

   749     histo.print_histo_on(st, _print_class_stats, _csv_format, _columns);

   750   } else {

   751     st->print_cr("ERROR: Ran out of C-heap; histogram not generated");

   752   }

   753   st->flush();

   754 }

   755 

   756 class FindInstanceClosure : public ObjectClosure {

   757  private:

   758   Klass* _klass;

   759   GrowableArray<oop>* _result;

   760 

   761  public:

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

   763 

   764   void do_object(oop obj) {

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

   766       _result->append(obj);

   767     }

   768   }

   769 };

   770 

   771 void HeapInspection::find_instances_at_safepoint(Klass* k, GrowableArray<oop>* result) {

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

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

   774 

   775   // Ensure that the heap is parsable

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

   777 

   778   // Iterate over objects in the heap

   779   FindInstanceClosure fic(k, result);

   780   // If this operation encounters a bad object when using CMS,

   781   // consider using safe_object_iterate() which avoids metadata

   782   // objects that may contain bad references.

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

   784 }