hotspot/src/share/vm/memory/heapInspection.cpp
author tonyp
Tue, 08 Nov 2011 00:41:28 -0500
changeset 10997 0be4b3be7197
parent 8921 14bfe81f2a9d
child 13195 be27e1b6a4b9
permissions -rw-r--r--
7099849: G1: include heap region information in hs_err files Reviewed-by: johnc, brutisso, poonam
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
8921
14bfe81f2a9d 7010070: Update all 2010 Oracle-changed OpenJDK files to have the proper copyright dates - second pass
trims
parents: 8076
diff changeset
     2
 * Copyright (c) 2002, 2011, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5402
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5402
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5402
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    26
#include "gc_interface/collectedHeap.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    27
#include "memory/genCollectedHeap.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    28
#include "memory/heapInspection.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    29
#include "memory/resourceArea.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    30
#include "oops/klassOop.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    31
#include "runtime/os.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    32
#include "utilities/globalDefinitions.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    33
#ifndef SERIALGC
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    34
#include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    35
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
// HeapInspection
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
int KlassInfoEntry::compare(KlassInfoEntry* e1, KlassInfoEntry* e2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
  if(e1->_instance_words > e2->_instance_words) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
    return -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
  } else if(e1->_instance_words < e2->_instance_words) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
    return 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
  return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
void KlassInfoEntry::print_on(outputStream* st) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
  const char* name;;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
  if (_klass->klass_part()->name() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
    name = _klass->klass_part()->external_name();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
    if (_klass == Universe::klassKlassObj())             name = "<klassKlass>";             else
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
    if (_klass == Universe::arrayKlassKlassObj())        name = "<arrayKlassKlass>";        else
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
    if (_klass == Universe::objArrayKlassKlassObj())     name = "<objArrayKlassKlass>";     else
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
    if (_klass == Universe::instanceKlassKlassObj())     name = "<instanceKlassKlass>";     else
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
    if (_klass == Universe::typeArrayKlassKlassObj())    name = "<typeArrayKlassKlass>";    else
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
    if (_klass == Universe::boolArrayKlassObj())         name = "<boolArrayKlass>";         else
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
    if (_klass == Universe::charArrayKlassObj())         name = "<charArrayKlass>";         else
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
    if (_klass == Universe::singleArrayKlassObj())       name = "<singleArrayKlass>";       else
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
    if (_klass == Universe::doubleArrayKlassObj())       name = "<doubleArrayKlass>";       else
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
    if (_klass == Universe::byteArrayKlassObj())         name = "<byteArrayKlass>";         else
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
    if (_klass == Universe::shortArrayKlassObj())        name = "<shortArrayKlass>";        else
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
    if (_klass == Universe::intArrayKlassObj())          name = "<intArrayKlass>";          else
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
    if (_klass == Universe::longArrayKlassObj())         name = "<longArrayKlass>";         else
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
    if (_klass == Universe::methodKlassObj())            name = "<methodKlass>";            else
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
    if (_klass == Universe::constMethodKlassObj())       name = "<constMethodKlass>";       else
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
    if (_klass == Universe::methodDataKlassObj())        name = "<methodDataKlass>";        else
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
    if (_klass == Universe::constantPoolKlassObj())      name = "<constantPoolKlass>";      else
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
    if (_klass == Universe::constantPoolCacheKlassObj()) name = "<constantPoolCacheKlass>"; else
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
    if (_klass == Universe::compiledICHolderKlassObj())  name = "<compiledICHolderKlass>";  else
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
      name = "<no name>";
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
  // simplify the formatting (ILP32 vs LP64) - always cast the numbers to 64-bit
184
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
    76
  st->print_cr(INT64_FORMAT_W(13) "  " UINT64_FORMAT_W(13) "  %s",
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
               (jlong)  _instance_count,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
               (julong) _instance_words * HeapWordSize,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
               name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
KlassInfoEntry* KlassInfoBucket::lookup(const klassOop k) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
  KlassInfoEntry* elt = _list;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
  while (elt != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
    if (elt->is_equal(k)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
      return elt;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
    elt = elt->next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  elt = new KlassInfoEntry(k, list());
184
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
    91
  // We may be out of space to allocate the new entry.
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
    92
  if (elt != NULL) {
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
    93
    set_list(elt);
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
    94
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  return elt;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
void KlassInfoBucket::iterate(KlassInfoClosure* cic) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  KlassInfoEntry* elt = _list;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  while (elt != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
    cic->do_cinfo(elt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
    elt = elt->next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
void KlassInfoBucket::empty() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  KlassInfoEntry* elt = _list;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
  _list = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
  while (elt != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
    KlassInfoEntry* next = elt->next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
    delete elt;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
    elt = next;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
KlassInfoTable::KlassInfoTable(int size, HeapWord* ref) {
184
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   117
  _size = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
  _ref = ref;
184
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   119
  _buckets = NEW_C_HEAP_ARRAY(KlassInfoBucket, size);
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   120
  if (_buckets != NULL) {
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   121
    _size = size;
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   122
    for (int index = 0; index < _size; index++) {
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   123
      _buckets[index].initialize();
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   124
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
KlassInfoTable::~KlassInfoTable() {
184
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   129
  if (_buckets != NULL) {
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   130
    for (int index = 0; index < _size; index++) {
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   131
      _buckets[index].empty();
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   132
    }
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   133
    FREE_C_HEAP_ARRAY(KlassInfoBucket, _buckets);
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   134
    _size = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
uint KlassInfoTable::hash(klassOop p) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
  assert(Universe::heap()->is_in_permanent((HeapWord*)p), "all klasses in permgen");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
  return (uint)(((uintptr_t)p - (uintptr_t)_ref) >> 2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
KlassInfoEntry* KlassInfoTable::lookup(const klassOop k) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
  uint         idx = hash(k) % _size;
184
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   145
  assert(_buckets != NULL, "Allocation failure should have been caught");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  KlassInfoEntry*  e   = _buckets[idx].lookup(k);
184
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   147
  // Lookup may fail if this is a new klass for which we
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   148
  // could not allocate space for an new entry.
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   149
  assert(e == NULL || k == e->klass(), "must be equal");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  return e;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
184
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   153
// Return false if the entry could not be recorded on account
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   154
// of running out of space required to create a new entry.
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   155
bool KlassInfoTable::record_instance(const oop obj) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
  klassOop      k = obj->klass();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  KlassInfoEntry* elt = lookup(k);
184
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   158
  // elt may be NULL if it's a new klass for which we
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   159
  // could not allocate space for a new entry in the hashtable.
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   160
  if (elt != NULL) {
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   161
    elt->set_count(elt->count() + 1);
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   162
    elt->set_words(elt->words() + obj->size());
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   163
    return true;
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   164
  } else {
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   165
    return false;
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   166
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
void KlassInfoTable::iterate(KlassInfoClosure* cic) {
184
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   170
  assert(_size == 0 || _buckets != NULL, "Allocation failure should have been caught");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  for (int index = 0; index < _size; index++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
    _buckets[index].iterate(cic);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
int KlassInfoHisto::sort_helper(KlassInfoEntry** e1, KlassInfoEntry** e2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  return (*e1)->compare(*e1,*e2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
KlassInfoHisto::KlassInfoHisto(const char* title, int estimatedCount) :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  _title(title) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
  _elements = new (ResourceObj::C_HEAP) GrowableArray<KlassInfoEntry*>(estimatedCount,true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
KlassInfoHisto::~KlassInfoHisto() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
  delete _elements;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
void KlassInfoHisto::add(KlassInfoEntry* cie) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
  elements()->append(cie);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
void KlassInfoHisto::sort() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  elements()->sort(KlassInfoHisto::sort_helper);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
void KlassInfoHisto::print_elements(outputStream* st) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  // simplify the formatting (ILP32 vs LP64) - store the sum in 64-bit
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  jlong total = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
  julong totalw = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
  for(int i=0; i < elements()->length(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
    st->print("%4d: ", i+1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
    elements()->at(i)->print_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
    total += elements()->at(i)->count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
    totalw += elements()->at(i)->words();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
  }
184
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   207
  st->print_cr("Total " INT64_FORMAT_W(13) "  " UINT64_FORMAT_W(13),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
               total, totalw * HeapWordSize);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
void KlassInfoHisto::print_on(outputStream* st) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
  st->print_cr("%s",title());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
  print_elements(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
class HistoClosure : public KlassInfoClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
  KlassInfoHisto* _cih;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
  HistoClosure(KlassInfoHisto* cih) : _cih(cih) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
  void do_cinfo(KlassInfoEntry* cie) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
    _cih->add(cie);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
class RecordInstanceClosure : public ObjectClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
  KlassInfoTable* _cit;
184
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   230
  size_t _missed_count;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
 public:
184
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   232
  RecordInstanceClosure(KlassInfoTable* cit) :
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   233
    _cit(cit), _missed_count(0) {}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
  void do_object(oop obj) {
184
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   236
    if (!_cit->record_instance(obj)) {
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   237
      _missed_count++;
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   238
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  }
184
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   240
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   241
  size_t missed_count() { return _missed_count; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
   244
void HeapInspection::heap_inspection(outputStream* st, bool need_prologue) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
  HeapWord* ref;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
  CollectedHeap* heap = Universe::heap();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 184
diff changeset
   249
  bool is_shared_heap = false;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
  switch (heap->kind()) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 184
diff changeset
   251
    case CollectedHeap::G1CollectedHeap:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
    case CollectedHeap::GenCollectedHeap: {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 184
diff changeset
   253
      is_shared_heap = true;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 184
diff changeset
   254
      SharedHeap* sh = (SharedHeap*)heap;
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
   255
      if (need_prologue) {
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
   256
        sh->gc_prologue(false /* !full */); // get any necessary locks, etc.
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
   257
      }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 184
diff changeset
   258
      ref = sh->perm_gen()->used_region().start();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
#ifndef SERIALGC
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
    case CollectedHeap::ParallelScavengeHeap: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
      ParallelScavengeHeap* psh = (ParallelScavengeHeap*)heap;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
      ref = psh->perm_gen()->object_space()->used_region().start();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
#endif // SERIALGC
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
    default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
      ShouldNotReachHere(); // Unexpected heap kind for this op
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
  // Collect klass instance info
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
  KlassInfoTable cit(KlassInfoTable::cit_size, ref);
184
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   273
  if (!cit.allocation_failed()) {
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   274
    // Iterate over objects in the heap
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   275
    RecordInstanceClosure ric(&cit);
1893
c82e388e17c5 6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents: 1388
diff changeset
   276
    // If this operation encounters a bad object when using CMS,
c82e388e17c5 6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents: 1388
diff changeset
   277
    // consider using safe_object_iterate() which avoids perm gen
c82e388e17c5 6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents: 1388
diff changeset
   278
    // objects that may contain bad references.
184
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   279
    Universe::heap()->object_iterate(&ric);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
184
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   281
    // Report if certain classes are not counted because of
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   282
    // running out of C-heap for the histogram.
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   283
    size_t missed_count = ric.missed_count();
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   284
    if (missed_count != 0) {
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   285
      st->print_cr("WARNING: Ran out of C-heap; undercounted " SIZE_FORMAT
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   286
                   " total instances in data below",
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   287
                   missed_count);
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   288
    }
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   289
    // Sort and print klass instance info
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   290
    KlassInfoHisto histo("\n"
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   291
                     " num     #instances         #bytes  class name\n"
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   292
                     "----------------------------------------------",
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   293
                     KlassInfoHisto::histo_initial_size);
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   294
    HistoClosure hc(&histo);
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   295
    cit.iterate(&hc);
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   296
    histo.sort();
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   297
    histo.print_on(st);
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   298
  } else {
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   299
    st->print_cr("WARNING: Ran out of C-heap; histogram not generated");
a2da5efb871c 6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents: 1
diff changeset
   300
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
  st->flush();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
   303
  if (need_prologue && is_shared_heap) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 184
diff changeset
   304
    SharedHeap* sh = (SharedHeap*)heap;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 184
diff changeset
   305
    sh->gc_epilogue(false /* !full */); // release all acquired locks, etc.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
class FindInstanceClosure : public ObjectClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
  klassOop _klass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
  GrowableArray<oop>* _result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
  FindInstanceClosure(klassOop k, GrowableArray<oop>* result) : _klass(k), _result(result) {};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
  void do_object(oop obj) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
    if (obj->is_a(_klass)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
      _result->append(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
void HeapInspection::find_instances_at_safepoint(klassOop k, GrowableArray<oop>* result) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
  assert(SafepointSynchronize::is_at_safepoint(), "all threads are stopped");
5402
c51fd0c1d005 6888953: some calls to function-like macros are missing semicolons
jcoomes
parents: 2154
diff changeset
   326
  assert(Heap_lock->is_locked(), "should have the Heap_lock");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
  // Ensure that the heap is parsable
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
  Universe::heap()->ensure_parsability(false);  // no need to retire TALBs
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
  // Iterate over objects in the heap
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
  FindInstanceClosure fic(k, result);
1893
c82e388e17c5 6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents: 1388
diff changeset
   333
  // If this operation encounters a bad object when using CMS,
c82e388e17c5 6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents: 1388
diff changeset
   334
  // consider using safe_object_iterate() which avoids perm gen
c82e388e17c5 6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents: 1388
diff changeset
   335
  // objects that may contain bad references.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
  Universe::heap()->object_iterate(&fic);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
}