1 /*
2 * Copyright (c) 2002, 2019, 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 #ifndef SHARE_MEMORY_HEAPINSPECTION_HPP
26 #define SHARE_MEMORY_HEAPINSPECTION_HPP
27
28 #include "memory/allocation.hpp"
29 #include "oops/objArrayOop.hpp"
30 #include "oops/oop.hpp"
31 #include "oops/annotations.hpp"
32 #include "utilities/macros.hpp"
33
34 #if INCLUDE_SERVICES
35
36
37 // HeapInspection
38
39 // KlassInfoTable is a bucket hash table that
40 // maps Klass*s to extra information:
41 // instance count and instance word size.
42 //
43 // A KlassInfoBucket is the head of a link list
44 // of KlassInfoEntry's
45 //
46 // KlassInfoHisto is a growable array of pointers
47 // to KlassInfoEntry's and is used to sort
48 // the entries.
49
50 #define HEAP_INSPECTION_COLUMNS_DO(f) \
51 f(inst_size, InstSize, \
52 "Size of each object instance of the Java class") \
53 f(inst_count, InstCount, \
54 "Number of object instances of the Java class") \
55 f(inst_bytes, InstBytes, \
56 "This is usually (InstSize * InstNum). The only exception is " \
57 "java.lang.Class, whose InstBytes also includes the slots " \
58 "used to store static fields. InstBytes is not counted in " \
59 "ROAll, RWAll or Total") \
60 f(mirror_bytes, Mirror, \
61 "Size of the Klass::java_mirror() object") \
62 f(klass_bytes, KlassBytes, \
63 "Size of the InstanceKlass or ArrayKlass for this class. " \
64 "Note that this includes VTab, ITab, OopMap") \
65 f(secondary_supers_bytes, K_secondary_supers, \
66 "Number of bytes used by the Klass::secondary_supers() array") \
67 f(vtab_bytes, VTab, \
68 "Size of the embedded vtable in InstanceKlass") \
69 f(itab_bytes, ITab, \
70 "Size of the embedded itable in InstanceKlass") \
71 f(nonstatic_oopmap_bytes, OopMap, \
72 "Size of the embedded nonstatic_oop_map in InstanceKlass") \
73 f(methods_array_bytes, IK_methods, \
74 "Number of bytes used by the InstanceKlass::methods() array") \
75 f(method_ordering_bytes, IK_method_ordering, \
76 "Number of bytes used by the InstanceKlass::method_ordering() array") \
77 f(default_methods_array_bytes, IK_default_methods, \
78 "Number of bytes used by the InstanceKlass::default_methods() array") \
79 f(default_vtable_indices_bytes, IK_default_vtable_indices, \
80 "Number of bytes used by the InstanceKlass::default_vtable_indices() array") \
81 f(local_interfaces_bytes, IK_local_interfaces, \
82 "Number of bytes used by the InstanceKlass::local_interfaces() array") \
83 f(transitive_interfaces_bytes, IK_transitive_interfaces, \
84 "Number of bytes used by the InstanceKlass::transitive_interfaces() array") \
85 f(fields_bytes, IK_fields, \
86 "Number of bytes used by the InstanceKlass::fields() array") \
87 f(inner_classes_bytes, IK_inner_classes, \
88 "Number of bytes used by the InstanceKlass::inner_classes() array") \
89 f(nest_members_bytes, IK_nest_members, \
90 "Number of bytes used by the InstanceKlass::nest_members() array") \
91 f(signers_bytes, IK_signers, \
92 "Number of bytes used by the InstanceKlass::singers() array") \
93 f(class_annotations_bytes, class_annotations, \
94 "Size of class annotations") \
95 f(class_type_annotations_bytes, class_type_annotations, \
96 "Size of class type annotations") \
97 f(fields_annotations_bytes, fields_annotations, \
98 "Size of field annotations") \
99 f(fields_type_annotations_bytes, fields_type_annotations, \
100 "Size of field type annotations") \
101 f(methods_annotations_bytes, methods_annotations, \
102 "Size of method annotations") \
103 f(methods_parameter_annotations_bytes, methods_parameter_annotations, \
104 "Size of method parameter annotations") \
105 f(methods_type_annotations_bytes, methods_type_annotations, \
106 "Size of methods type annotations") \
107 f(methods_default_annotations_bytes, methods_default_annotations, \
108 "Size of methods default annotations") \
109 f(annotations_bytes, annotations, \
110 "Size of all annotations") \
111 f(cp_bytes, Cp, \
112 "Size of InstanceKlass::constants()") \
113 f(cp_tags_bytes, CpTags, \
114 "Size of InstanceKlass::constants()->tags()") \
115 f(cp_cache_bytes, CpCache, \
116 "Size of InstanceKlass::constants()->cache()") \
117 f(cp_operands_bytes, CpOperands, \
118 "Size of InstanceKlass::constants()->operands()") \
119 f(cp_refmap_bytes, CpRefMap, \
120 "Size of InstanceKlass::constants()->reference_map()") \
121 f(cp_all_bytes, CpAll, \
122 "Sum of Cp + CpTags + CpCache + CpOperands + CpRefMap") \
123 f(method_count, MethodCount, \
124 "Number of methods in this class") \
125 f(method_bytes, MethodBytes, \
126 "Size of the Method object") \
127 f(const_method_bytes, ConstMethod, \
128 "Size of the ConstMethod object") \
129 f(method_data_bytes, MethodData, \
130 "Size of the MethodData object") \
131 f(stackmap_bytes, StackMap, \
132 "Size of the stackmap_data") \
133 f(bytecode_bytes, Bytecodes, \
134 "Of the MethodBytes column, how much are the space taken up by bytecodes") \
135 f(method_all_bytes, MethodAll, \
136 "Sum of MethodBytes + Constmethod + Stackmap + Methoddata") \
137 f(ro_bytes, ROAll, \
138 "Size of all class meta data that could (potentially) be placed " \
139 "in read-only memory. (This could change with CDS design)") \
140 f(rw_bytes, RWAll, \
141 "Size of all class meta data that must be placed in read/write " \
142 "memory. (This could change with CDS design) ") \
143 f(total_bytes, Total, \
144 "ROAll + RWAll. Note that this does NOT include InstBytes.")
145
146 // Size statistics for a Klass - filled in by Klass::collect_statistics()
147 class KlassSizeStats {
148 public:
149 #define COUNT_KLASS_SIZE_STATS_FIELD(field, name, help) _index_ ## field,
150 #define DECLARE_KLASS_SIZE_STATS_FIELD(field, name, help) julong _ ## field;
151
152 enum {
153 HEAP_INSPECTION_COLUMNS_DO(COUNT_KLASS_SIZE_STATS_FIELD)
154 _num_columns
155 };
156
157 HEAP_INSPECTION_COLUMNS_DO(DECLARE_KLASS_SIZE_STATS_FIELD)
158
159 static int count(oop x);
160
161 static int count_array(objArrayOop x);
162
163 template <class T> static int count(T* x) {
164 return (HeapWordSize * ((x) ? (x)->size() : 0));
165 }
166
167 template <class T> static int count_array(T* x) {
168 if (x == NULL) {
169 return 0;
170 }
171 if (x->length() == 0) {
172 // This is a shared array, e.g., Universe::the_empty_int_array(). Don't
173 // count it to avoid double-counting.
174 return 0;
175 }
176 return HeapWordSize * x->size();
177 }
178 };
179
180
181
182
183 class KlassInfoEntry: public CHeapObj<mtInternal> {
184 private:
185 KlassInfoEntry* _next;
186 Klass* _klass;
187 long _instance_count;
188 size_t _instance_words;
189 long _index;
190 bool _do_print; // True if we should print this class when printing the class hierarchy.
191 GrowableArray<KlassInfoEntry*>* _subclasses;
192
193 public:
194 KlassInfoEntry(Klass* k, KlassInfoEntry* next) :
195 _next(next), _klass(k), _instance_count(0), _instance_words(0), _index(-1),
196 _do_print(false), _subclasses(NULL)
197 {}
198 ~KlassInfoEntry();
199 KlassInfoEntry* next() const { return _next; }
200 bool is_equal(const Klass* k) { return k == _klass; }
201 Klass* klass() const { return _klass; }
202 long count() const { return _instance_count; }
203 void set_count(long ct) { _instance_count = ct; }
204 size_t words() const { return _instance_words; }
205 void set_words(size_t wds) { _instance_words = wds; }
206 void set_index(long index) { _index = index; }
207 long index() const { return _index; }
208 GrowableArray<KlassInfoEntry*>* subclasses() const { return _subclasses; }
209 void add_subclass(KlassInfoEntry* cie);
210 void set_do_print(bool do_print) { _do_print = do_print; }
211 bool do_print() const { return _do_print; }
212 int compare(KlassInfoEntry* e1, KlassInfoEntry* e2);
213 void print_on(outputStream* st) const;
214 const char* name() const;
215 };
216
217 class KlassInfoClosure : public StackObj {
218 public:
219 // Called for each KlassInfoEntry.
220 virtual void do_cinfo(KlassInfoEntry* cie) = 0;
221 };
222
223 class KlassInfoBucket: public CHeapObj<mtInternal> {
224 private:
225 KlassInfoEntry* _list;
226 KlassInfoEntry* list() { return _list; }
227 void set_list(KlassInfoEntry* l) { _list = l; }
228 public:
229 KlassInfoEntry* lookup(Klass* k);
230 void initialize() { _list = NULL; }
231 void empty();
232 void iterate(KlassInfoClosure* cic);
233 };
234
235 class KlassInfoTable: public StackObj {
236 private:
237 static const int _num_buckets = 20011;
238 size_t _size_of_instances_in_words;
239
240 // An aligned reference address (typically the least
241 // address in the perm gen) used for hashing klass
242 // objects.
243 HeapWord* _ref;
244
245 KlassInfoBucket* _buckets;
246 uint hash(const Klass* p);
247 KlassInfoEntry* lookup(Klass* k); // allocates if not found!
248
249 class AllClassesFinder;
250
251 public:
252 KlassInfoTable(bool add_all_classes);
253 ~KlassInfoTable();
254 bool record_instance(const oop obj);
255 void iterate(KlassInfoClosure* cic);
256 bool allocation_failed() { return _buckets == NULL; }
257 size_t size_of_instances_in_words() const;
258
259 friend class KlassInfoHisto;
260 friend class KlassHierarchy;
261 };
262
263 class KlassHierarchy : AllStatic {
264 public:
265 static void print_class_hierarchy(outputStream* st, bool print_interfaces, bool print_subclasses,
266 char* classname);
267
268 private:
269 static void set_do_print_for_class_hierarchy(KlassInfoEntry* cie, KlassInfoTable* cit,
270 bool print_subclasse);
271 static void print_class(outputStream* st, KlassInfoEntry* cie, bool print_subclasses);
272 };
273
274 class KlassInfoHisto : public StackObj {
275 private:
276 static const int _histo_initial_size = 1000;
277 KlassInfoTable *_cit;
278 GrowableArray<KlassInfoEntry*>* _elements;
279 GrowableArray<KlassInfoEntry*>* elements() const { return _elements; }
280 static int sort_helper(KlassInfoEntry** e1, KlassInfoEntry** e2);
281 void print_elements(outputStream* st) const;
282 void print_class_stats(outputStream* st, bool csv_format, const char *columns);
283 julong annotations_bytes(Array<AnnotationArray*>* p) const;
284 const char *_selected_columns;
285 bool is_selected(const char *col_name);
286 void print_title(outputStream* st, bool csv_format,
287 bool selected_columns_table[], int width_table[],
288 const char *name_table[]);
289
290 template <class T> static int count_bytes(T* x) {
291 return (HeapWordSize * ((x) ? (x)->size() : 0));
292 }
293
294 template <class T> static int count_bytes_array(T* x) {
295 if (x == NULL) {
296 return 0;
297 }
298 if (x->length() == 0) {
299 // This is a shared array, e.g., Universe::the_empty_int_array(). Don't
300 // count it to avoid double-counting.
301 return 0;
302 }
303 return HeapWordSize * x->size();
304 }
305
306 static void print_julong(outputStream* st, int width, julong n) {
307 int num_spaces = width - julong_width(n);
308 if (num_spaces > 0) {
309 st->print("%*s", num_spaces, "");
310 }
311 st->print(JULONG_FORMAT, n);
312 }
313
314 static int julong_width(julong n) {
315 if (n == 0) {
316 return 1;
317 }
318 int w = 0;
319 while (n > 0) {
320 n /= 10;
321 w += 1;
322 }
323 return w;
324 }
325
326 static int col_width(julong n, const char *name) {
327 int w = julong_width(n);
328 int min = (int)(strlen(name));
329 if (w < min) {
330 w = min;
331 }
332 // add a leading space for separation.
333 return w + 1;
334 }
335
336 public:
337 KlassInfoHisto(KlassInfoTable* cit);
338 ~KlassInfoHisto();
339 void add(KlassInfoEntry* cie);
340 void print_histo_on(outputStream* st, bool print_class_stats, bool csv_format, const char *columns);
341 void sort();
342 };
343
344 class PrintClassLayout : AllStatic {
345 public:
346 static void print_class_layout(outputStream* st, char* classname);
347 };
348
349 #endif // INCLUDE_SERVICES
350
351 // These declarations are needed since the declaration of KlassInfoTable and
352 // KlassInfoClosure are guarded by #if INLCUDE_SERVICES
353 class KlassInfoTable;
354 class KlassInfoClosure;
355
356 class HeapInspection : public StackObj {
357 bool _csv_format; // "comma separated values" format for spreadsheet.
358 bool _print_help;
359 bool _print_class_stats;
360 const char* _columns;
361 public:
362 HeapInspection(bool csv_format, bool print_help,
363 bool print_class_stats, const char *columns) :
364 _csv_format(csv_format), _print_help(print_help),
365 _print_class_stats(print_class_stats), _columns(columns) {}
366 void heap_inspection(outputStream* st) NOT_SERVICES_RETURN;
367 size_t populate_table(KlassInfoTable* cit, BoolObjectClosure* filter = NULL) NOT_SERVICES_RETURN_(0);
368 static void find_instances_at_safepoint(Klass* k, GrowableArray<oop>* result) NOT_SERVICES_RETURN;
369 private:
370 void iterate_over_heap(KlassInfoTable* cit, BoolObjectClosure* filter = NULL);
371 };
372
373 #endif // SHARE_MEMORY_HEAPINSPECTION_HPP