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