1 /*
2 * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 *
8 * - Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 *
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * - Neither the name of Oracle nor the names of its
16 * contributors may be used to endorse or promote products derived
17 * from this software without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
20 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
21 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
26 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
27 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
28 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
29 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 /*
33 * This source code is provided to illustrate the usage of a given feature
34 * or technique and has been deliberately simplified. Additional steps
35 * required for a production-quality application, such as security checks,
36 * input validation and proper error handling, might not be present in
37 * this sample code.
38 */
39
40
41 /* Allocation site table. */
42
43 /*
44 * Every object allocation will have a place where it was allocated,
45 * this is the purpose of the SiteIndex.
46 *
47 * The allocation site or SiteIndex is unique via a (class,trace) pair.
48 *
49 * The allocation statistics are accumulated in the SiteInfo for each
50 * site.
51 *
52 * This file also contains the heap iterate logic, which is closely
53 * associated with the site table, the object table, and the
54 * reference table. Each object has an element in the object table
55 * and as the heap is traversed, and information contained in each
56 * object is saved as a linked list of references.
57 *
58 */
59
60 #include "hprof.h"
61
62 typedef struct SiteKey {
63 ClassIndex cnum; /* Unique class number */
64 TraceIndex trace_index; /* Trace number */
65 } SiteKey;
66
67 typedef struct SiteInfo {
68 int changed; /* Objects at this site changed? */
69 unsigned n_alloced_instances; /* Total allocated instances */
70 unsigned n_alloced_bytes; /* Total bytes allocated from here */
71 unsigned n_live_instances; /* Live instances for this site. */
72 unsigned n_live_bytes; /* Live byte count for this site. */
73 } SiteInfo;
74
75 typedef struct IterateInfo {
76 SiteIndex * site_nums;
77 int count;
78 int changed_only;
79 } IterateInfo;
80
81 /* Private internal functions. */
82
83 static SiteKey*
84 get_pkey(SiteIndex index)
85 {
86 void *key_ptr;
87 int key_len;
88
89 table_get_key(gdata->site_table, index, &key_ptr, &key_len);
90 HPROF_ASSERT(key_len==sizeof(SiteKey));
91 HPROF_ASSERT(key_ptr!=NULL);
92 return (SiteKey*)key_ptr;
93 }
94
95 ClassIndex
96 site_get_class_index(SiteIndex index)
97 {
98 SiteKey *pkey;
99
100 pkey = get_pkey(index);
101 return pkey->cnum;
102 }
103
104 TraceIndex
105 site_get_trace_index(SiteIndex index)
106 {
107 SiteKey *pkey;
108
109 pkey = get_pkey(index);
110 return pkey->trace_index;
111 }
112
113 static SiteInfo *
114 get_info(SiteIndex index)
115 {
116 SiteInfo *info;
117
118 info = (SiteInfo*)table_get_info(gdata->site_table, index);
119 return info;
120 }
121
122 static void
123 list_item(TableIndex i, void *key_ptr, int key_len, void *info_ptr, void *arg)
124 {
125 SiteKey *pkey;
126 jlong n_alloced_instances;
127 jlong n_alloced_bytes;
128 jlong n_live_instances;
129 jlong n_live_bytes;
130
131 HPROF_ASSERT(key_ptr!=NULL);
132 HPROF_ASSERT(key_len==sizeof(SiteKey));
133 pkey = (SiteKey*)key_ptr;
134
135 if ( info_ptr != NULL ) {
136 SiteInfo *info;
137
138 info = (SiteInfo *)info_ptr;
139 n_alloced_instances = info->n_alloced_instances;
140 n_alloced_bytes = info->n_alloced_bytes;
141 n_live_instances = info->n_live_instances;
142 n_live_bytes = info->n_live_bytes;
143 } else {
144 n_alloced_instances = 0;
145 n_alloced_bytes = 0;
146 n_live_instances = 0;
147 n_live_bytes = 0;
148 }
149
150 debug_message( "Site 0x%08x: class=0x%08x, trace=0x%08x, "
151 "Ninst=(%d,%d), Nbytes=(%d,%d), "
152 "Nlive=(%d,%d), NliveBytes=(%d,%d)\n",
153 i,
154 pkey->cnum,
155 pkey->trace_index,
156 jlong_high(n_alloced_instances), jlong_low(n_alloced_instances),
157 jlong_high(n_alloced_bytes), jlong_low(n_alloced_bytes),
158 jlong_high(n_live_instances), jlong_low(n_live_instances),
159 jlong_high(n_live_bytes), jlong_low(n_live_bytes));
160 }
161
162 static void
163 collect_iterator(TableIndex i, void *key_ptr, int key_len, void *info_ptr, void *arg)
164 {
165 IterateInfo *iterate;
166
167 HPROF_ASSERT(key_ptr!=NULL);
168 HPROF_ASSERT(key_len==sizeof(SiteKey));
169 HPROF_ASSERT(arg!=NULL);
170 iterate = (IterateInfo *)arg;
171
172 if ( iterate->changed_only ) {
173 SiteInfo *info;
174
175 info = (SiteInfo *)info_ptr;
176 if ( info==NULL || !info->changed ) {
177 return;
178 }
179 }
180 iterate->site_nums[iterate->count++] = i;
181 }
182
183 static void
184 mark_unchanged_iterator(TableIndex i, void *key_ptr, int key_len, void *info_ptr, void *arg)
185 {
186 SiteInfo *info;
187
188 HPROF_ASSERT(key_ptr!=NULL);
189 HPROF_ASSERT(key_len==sizeof(SiteKey));
190
191 info = (SiteInfo *)info_ptr;
192 if ( info != NULL ) {
193 info->changed = 0;
194 }
195 }
196
197 static int
198 qsort_compare_allocated_bytes(const void *p_site1, const void *p_site2)
199 {
200 SiteIndex site1;
201 SiteIndex site2;
202 SiteInfo *info1;
203 SiteInfo *info2;
204
205 HPROF_ASSERT(p_site1!=NULL);
206 HPROF_ASSERT(p_site2!=NULL);
207 site1 = *(SiteIndex *)p_site1;
208 site2 = *(SiteIndex *)p_site2;
209 info1 = get_info(site1);
210 info2 = get_info(site2);
211 return info2->n_alloced_bytes - info1->n_alloced_bytes;
212 }
213
214 static int
215 qsort_compare_live_bytes(const void *p_site1, const void *p_site2)
216 {
217 SiteIndex site1;
218 SiteIndex site2;
219 SiteInfo *info1;
220 SiteInfo *info2;
221
222 HPROF_ASSERT(p_site1!=NULL);
223 HPROF_ASSERT(p_site2!=NULL);
224 site1 = *(SiteIndex *)p_site1;
225 site2 = *(SiteIndex *)p_site2;
226 info1 = get_info(site1);
227 info2 = get_info(site2);
228 return info2->n_live_bytes - info1->n_live_bytes;
229 }
230
231 static ClassIndex
232 find_cnum(jlong class_tag)
233 {
234 ClassIndex cnum;
235 ObjectIndex class_object_index;
236 SiteIndex class_site_index;
237 SiteKey *pkey;
238
239 HPROF_ASSERT(class_tag!=(jlong)0);
240 class_object_index = tag_extract(class_tag);
241 class_site_index = object_get_site(class_object_index);
242 pkey = get_pkey(class_site_index);
243 cnum = pkey->cnum;
244 return cnum;
245 }
246
247 /* Create tag and object entry for an untagged object (should be rare) */
248 static jlong
249 make_new_tag(jlong class_tag, jlong size, TraceIndex trace_index,
250 SerialNumber thread_serial_num,
251 ObjectIndex *pindex, SiteIndex *psite)
252 {
253 ObjectIndex object_index;
254 SiteIndex object_site_index;
255
256 HPROF_ASSERT(class_tag!=(jlong)0);
257 object_site_index = site_find_or_create(find_cnum(class_tag), trace_index);
258 object_index = object_new(object_site_index, (jint)size,
259 OBJECT_SYSTEM, thread_serial_num);
260 if ( pindex != NULL ) {
261 *pindex = object_index;
262 }
263 if ( psite != NULL ) {
264 *psite = object_site_index;
265 }
266 return tag_create(object_index);
267 }
268
269 /* Setup tag on root object, if tagged return object index and site index */
270 static void
271 setup_tag_on_root(jlong *tag_ptr, jlong class_tag, jlong size,
272 SerialNumber thread_serial_num,
273 ObjectIndex *pindex, SiteIndex *psite)
274 {
275 HPROF_ASSERT(class_tag!=(jlong)0);
276 if ( (*tag_ptr) != (jlong)0 ) {
277 if ( pindex != NULL ) {
278 *pindex = tag_extract(*tag_ptr);
279 }
280 if ( psite != NULL ) {
281 *psite = object_get_site(tag_extract(*tag_ptr));
282 }
283 } else {
284 /* Create and set the tag. */
285 *tag_ptr = make_new_tag(class_tag, size, gdata->system_trace_index,
286 thread_serial_num, pindex, psite);
287 }
288 }
289
290 /* External interfaces */
291
292 SiteIndex
293 site_find_or_create(ClassIndex cnum, TraceIndex trace_index)
294 {
295 SiteIndex index;
296 static SiteKey empty_key;
297 SiteKey key;
298
299 key = empty_key;
300 HPROF_ASSERT(cnum!=0);
301 HPROF_ASSERT(trace_index!=0);
302 key.cnum = cnum;
303 key.trace_index = trace_index;
304 index = table_find_or_create_entry(gdata->site_table,
305 &key, (int)sizeof(key), NULL, NULL);
306 return index;
307 }
308
309 void
310 site_init(void)
311 {
312 HPROF_ASSERT(gdata->site_table==NULL);
313 gdata->site_table = table_initialize("Site",
314 1024, 1024, 511, (int)sizeof(SiteInfo));
315 }
316
317 void
318 site_list(void)
319 {
320 debug_message(
321 "--------------------- Site Table ------------------------\n");
322 table_walk_items(gdata->site_table, &list_item, NULL);
323 debug_message(
324 "----------------------------------------------------------\n");
325 }
326
327 void
328 site_cleanup(void)
329 {
330 table_cleanup(gdata->site_table, NULL, NULL);
331 gdata->site_table = NULL;
332 }
333
334 void
335 site_update_stats(SiteIndex index, jint size, jint hits)
336 {
337 SiteInfo *info;
338
339 table_lock_enter(gdata->site_table); {
340 info = get_info(index);
341
342 info->n_live_instances += hits;
343 info->n_live_bytes += size;
344 info->changed = 1;
345
346 gdata->total_live_bytes += size;
347 gdata->total_live_instances += hits;
348
349 if ( size > 0 ) {
350 info->n_alloced_instances += hits;
351 info->n_alloced_bytes += size;
352 gdata->total_alloced_bytes =
353 jlong_add(gdata->total_alloced_bytes, jint_to_jlong(size));
354 gdata->total_alloced_instances =
355 jlong_add(gdata->total_alloced_instances, jint_to_jlong(hits));
356 }
357 } table_lock_exit(gdata->site_table);
358 }
359
360 /* Output allocation sites, up to the given cut-off point, and according
361 * to the given flags:
362 *
363 * SITE_DUMP_INCREMENTAL only dump what's changed since last dump.
364 * SITE_SORT_BY_ALLOC sort sites by total allocation rather
365 * than live data.
366 * SITE_FORCE_GC force a GC before the site dump.
367 */
368
369 void
370 site_write(JNIEnv *env, int flags, double cutoff)
371 {
372 HPROF_ASSERT(gdata->site_table!=NULL);
373 LOG3("site_write", "flags", flags);
374
375 if (flags & SITE_FORCE_GC) {
376 runGC();
377 }
378
379 HPROF_ASSERT(gdata->total_live_bytes!=0);
380
381 rawMonitorEnter(gdata->data_access_lock); {
382
383 IterateInfo iterate;
384 int site_table_size;
385 double accum_percent;
386 void * comment_str;
387 int i;
388 int cutoff_count;
389 int nbytes;
390
391 accum_percent = 0;
392 site_table_size = table_element_count(gdata->site_table);
393
394 (void)memset(&iterate, 0, sizeof(iterate));
395 nbytes = site_table_size * (int)sizeof(SiteIndex);
396 if ( nbytes > 0 ) {
397 iterate.site_nums = HPROF_MALLOC(nbytes);
398 (void)memset(iterate.site_nums, 0, nbytes);
399 }
400 iterate.count = 0;
401 iterate.changed_only = flags & SITE_DUMP_INCREMENTAL;
402 table_walk_items(gdata->site_table, &collect_iterator, &iterate);
403
404 site_table_size = iterate.count;
405
406 if (flags & SITE_SORT_BY_ALLOC) {
407 comment_str = "allocated bytes";
408 qsort(iterate.site_nums, site_table_size, sizeof(SiteIndex),
409 &qsort_compare_allocated_bytes);
410 } else {
411 comment_str = "live bytes";
412 qsort(iterate.site_nums, site_table_size, sizeof(SiteIndex),
413 &qsort_compare_live_bytes);
414 }
415
416 trace_output_unmarked(env);
417
418 cutoff_count = 0;
419 for (i = 0; i < site_table_size; i++) {
420 SiteInfo *info;
421 SiteIndex index;
422 double ratio;
423
424 index= iterate.site_nums[i];
425 HPROF_ASSERT(index!=0);
426 info = get_info(index);
427 ratio = (double)info->n_live_bytes / (double)gdata->total_live_bytes;
428 if (ratio < cutoff) {
429 break;
430 }
431 cutoff_count++;
432 }
433
434 io_write_sites_header( comment_str,
435 flags,
436 cutoff,
437 gdata->total_live_bytes,
438 gdata->total_live_instances,
439 gdata->total_alloced_bytes,
440 gdata->total_alloced_instances,
441 cutoff_count);
442
443 for (i = 0; i < cutoff_count; i++) {
444 SiteInfo *info;
445 SiteKey *pkey;
446 SiteIndex index;
447 char *class_signature;
448 double ratio;
449
450 index = iterate.site_nums[i];
451 pkey = get_pkey(index);
452 info = get_info(index);
453
454 ratio = (double)info->n_live_bytes / (double)gdata->total_live_bytes;
455 accum_percent += ratio;
456
457 class_signature = string_get(class_get_signature(pkey->cnum));
458
459 io_write_sites_elem(i + 1,
460 ratio,
461 accum_percent,
462 class_signature,
463 class_get_serial_number(pkey->cnum),
464 trace_get_serial_number(pkey->trace_index),
465 info->n_live_bytes,
466 info->n_live_instances,
467 info->n_alloced_bytes,
468 info->n_alloced_instances);
469 }
470
471 io_write_sites_footer();
472
473 table_walk_items(gdata->site_table, &mark_unchanged_iterator, NULL);
474
475 if ( iterate.site_nums != NULL ) {
476 HPROF_FREE(iterate.site_nums);
477 }
478
479 } rawMonitorExit(gdata->data_access_lock);
480 }
481
482 /* Primitive array data callback for FollowReferences */
483 static jint JNICALL
484 cbPrimArrayData(jlong class_tag, jlong size, jlong* tag_ptr,
485 jint element_count, jvmtiPrimitiveType element_type,
486 const void* elements, void* user_data)
487 {
488 ObjectIndex object_index;
489 RefIndex ref_index;
490 RefIndex prev_ref_index;
491
492 HPROF_ASSERT(tag_ptr!=NULL);
493 HPROF_ASSERT(class_tag!=(jlong)0);
494 HPROF_ASSERT((*tag_ptr)!=(jlong)0);
495 if ( class_tag == (jlong)0 || (*tag_ptr) == (jlong)0 ) {
496 /* We can't do anything with a class_tag==0, just skip it */
497 return JVMTI_VISIT_OBJECTS;
498 }
499
500 /* Assume object has been tagged, get object index */
501 object_index = tag_extract((*tag_ptr));
502
503 /* Save string data */
504 prev_ref_index = object_get_references(object_index);
505 ref_index = reference_prim_array(prev_ref_index,
506 element_type, elements, element_count);
507 object_set_references(object_index, ref_index);
508
509 return JVMTI_VISIT_OBJECTS;
510 }
511
512 /* Primitive field data callback for FollowReferences */
513 static jint JNICALL
514 cbPrimFieldData(jvmtiHeapReferenceKind reference_kind,
515 const jvmtiHeapReferenceInfo* reference_info, jlong class_tag,
516 jlong* tag_ptr, jvalue value, jvmtiPrimitiveType value_type,
517 void* user_data)
518 {
519 ObjectIndex object_index;
520 jint field_index;
521 RefIndex ref_index;
522 RefIndex prev_ref_index;
523
524 HPROF_ASSERT(tag_ptr!=NULL);
525 HPROF_ASSERT(class_tag!=(jlong)0);
526 HPROF_ASSERT((*tag_ptr)!=(jlong)0);
527 if ( class_tag == (jlong)0 || (*tag_ptr) == (jlong)0 ) {
528 /* We can't do anything with a class_tag==0, just skip it */
529 return JVMTI_VISIT_OBJECTS;
530 }
531
532 /* If the field is 0, just skip it, we assume 0 */
533 if ( value.j == (jlong)0 ) {
534 return JVMTI_VISIT_OBJECTS;
535 }
536
537 /* Get field index */
538 field_index = reference_info->field.index;
539
540 /* We assume the object was tagged */
541 object_index = tag_extract((*tag_ptr));
542
543 /* Save primitive field data */
544 prev_ref_index = object_get_references(object_index);
545 ref_index = reference_prim_field(prev_ref_index, reference_kind,
546 value_type, value, field_index);
547 object_set_references(object_index, ref_index);
548
549 return JVMTI_VISIT_OBJECTS;
550 }
551
552 static SerialNumber
553 checkThreadSerialNumber(SerialNumber thread_serial_num)
554 {
555 TlsIndex tls_index;
556
557 if ( thread_serial_num == gdata->unknown_thread_serial_num ) {
558 return thread_serial_num;
559 }
560 tls_index = tls_find(thread_serial_num);
561 if ( tls_index != 0 && tls_get_in_heap_dump(tls_index) != 0 ) {
562 return thread_serial_num;
563 }
564 return gdata->unknown_thread_serial_num;
565 }
566
567 /* Get the object index and thread serial number for this local object */
568 static void
569 localReference(jlong *tag_ptr, jlong class_tag, jlong thread_tag,
570 jlong size, ObjectIndex *pobject_index, SerialNumber *pthread_serial_num)
571 {
572 ObjectIndex object_index;
573 SerialNumber thread_serial_num;
574
575 HPROF_ASSERT(pobject_index!=NULL);
576 HPROF_ASSERT(pthread_serial_num!=NULL);
577 HPROF_ASSERT(tag_ptr!=NULL);
578 HPROF_ASSERT(class_tag!=(jlong)0);
579
580 if ( (*tag_ptr) != (jlong)0 ) {
581 object_index = tag_extract(*tag_ptr);
582 thread_serial_num = object_get_thread_serial_number(object_index);
583 thread_serial_num = checkThreadSerialNumber(thread_serial_num);
584 } else {
585 if ( thread_tag != (jlong)0 ) {
586 ObjectIndex thread_object_index;
587
588 thread_object_index = tag_extract(thread_tag);
589 thread_serial_num =
590 object_get_thread_serial_number(thread_object_index);
591 thread_serial_num = checkThreadSerialNumber(thread_serial_num);
592 } else {
593 thread_serial_num = gdata->unknown_thread_serial_num;
594 }
595 /* Create and set the tag. */
596 *tag_ptr = make_new_tag(class_tag, size, gdata->system_trace_index,
597 thread_serial_num, &object_index, NULL);
598 }
599
600 HPROF_ASSERT(thread_serial_num!=0);
601 HPROF_ASSERT(object_index!=0);
602 *pobject_index = object_index;
603 *pthread_serial_num = thread_serial_num;
604 }
605
606 /* Store away plain object reference information */
607 static jint
608 objectReference(jvmtiHeapReferenceKind reference_kind,
609 const jvmtiHeapReferenceInfo* reference_info,
610 jlong class_tag, jlong size, jlong* tag_ptr,
611 jlong* referrer_tag_ptr, jint length)
612 {
613 ObjectIndex object_index;
614 jint reference_index;
615 RefIndex ref_index;
616 RefIndex prev_ref_index;
617 ObjectIndex referrer_object_index;
618 jlong object_tag;
619
620 HPROF_ASSERT(tag_ptr!=NULL);
621 HPROF_ASSERT(class_tag!=(jlong)0);
622 HPROF_ASSERT(referrer_tag_ptr!=NULL);
623 HPROF_ASSERT((*referrer_tag_ptr)!=(jlong)0);
624 if ( class_tag == (jlong)0 || (*referrer_tag_ptr) == (jlong)0 ) {
625 /* We can't do anything with a class_tag==0, just skip it */
626 return JVMTI_VISIT_OBJECTS;
627 }
628
629 switch ( reference_kind ) {
630 case JVMTI_HEAP_REFERENCE_CLASS_LOADER:
631 case JVMTI_HEAP_REFERENCE_INTERFACE:
632 default:
633 /* Currently we don't need these */
634 return JVMTI_VISIT_OBJECTS;
635 case JVMTI_HEAP_REFERENCE_FIELD:
636 case JVMTI_HEAP_REFERENCE_STATIC_FIELD:
637 reference_index = reference_info->field.index;
638 break;
639 case JVMTI_HEAP_REFERENCE_ARRAY_ELEMENT:
640 reference_index = reference_info->array.index;
641 break;
642 case JVMTI_HEAP_REFERENCE_CONSTANT_POOL:
643 reference_index = reference_info->constant_pool.index;
644 break;
645 case JVMTI_HEAP_REFERENCE_SIGNERS:
646 case JVMTI_HEAP_REFERENCE_PROTECTION_DOMAIN:
647 reference_index = 0;
648 break;
649 }
650
651 /* We assume the referrer is tagged */
652 referrer_object_index = tag_extract((*referrer_tag_ptr));
653
654 /* Now check the referree */
655 object_tag = *tag_ptr;
656 if ( object_tag != (jlong)0 ) {
657 object_index = tag_extract(object_tag);
658 } else {
659 /* Create and set the tag. */
660 object_tag = make_new_tag(class_tag, size, gdata->system_trace_index,
661 gdata->unknown_thread_serial_num,
662 &object_index, NULL);
663 *tag_ptr = object_tag;
664 }
665 HPROF_ASSERT(object_index!=0);
666
667 /* Save reference information */
668 prev_ref_index = object_get_references(referrer_object_index);
669 ref_index = reference_obj(prev_ref_index, reference_kind,
670 object_index, reference_index, length);
671 object_set_references(referrer_object_index, ref_index);
672
673 return JVMTI_VISIT_OBJECTS;
674 }
675
676 /* FollowReferences heap_reference_callback */
677 static jint JNICALL
678 cbReference(jvmtiHeapReferenceKind reference_kind,
679 const jvmtiHeapReferenceInfo* reference_info,
680 jlong class_tag, jlong referrer_class_tag,
681 jlong size, jlong* tag_ptr,
682 jlong* referrer_tag_ptr, jint length, void* user_data)
683 {
684 ObjectIndex object_index;
685
686 /* Only calls to Allocate, Deallocate, RawMonitorEnter & RawMonitorExit
687 * are allowed here (see the JVMTI Spec).
688 */
689
690 HPROF_ASSERT(tag_ptr!=NULL);
691 HPROF_ASSERT(class_tag!=(jlong)0);
692 if ( class_tag == (jlong)0 ) {
693 /* We can't do anything with a class_tag==0, just skip it */
694 return JVMTI_VISIT_OBJECTS;
695 }
696
697 switch ( reference_kind ) {
698
699 case JVMTI_HEAP_REFERENCE_FIELD:
700 case JVMTI_HEAP_REFERENCE_ARRAY_ELEMENT:
701 case JVMTI_HEAP_REFERENCE_CLASS_LOADER:
702 case JVMTI_HEAP_REFERENCE_SIGNERS:
703 case JVMTI_HEAP_REFERENCE_PROTECTION_DOMAIN:
704 case JVMTI_HEAP_REFERENCE_INTERFACE:
705 case JVMTI_HEAP_REFERENCE_STATIC_FIELD:
706 case JVMTI_HEAP_REFERENCE_CONSTANT_POOL:
707 return objectReference(reference_kind, reference_info,
708 class_tag, size, tag_ptr, referrer_tag_ptr, length);
709
710 case JVMTI_HEAP_REFERENCE_JNI_GLOBAL: {
711 SerialNumber trace_serial_num;
712 SerialNumber gref_serial_num;
713 TraceIndex trace_index;
714 SiteIndex object_site_index;
715
716 setup_tag_on_root(tag_ptr, class_tag, size,
717 gdata->unknown_thread_serial_num,
718 &object_index, &object_site_index);
719 if ( object_site_index != 0 ) {
720 SiteKey *pkey;
721
722 pkey = get_pkey(object_site_index);
723 trace_index = pkey->trace_index;
724 } else {
725 trace_index = gdata->system_trace_index;
726 }
727 trace_serial_num = trace_get_serial_number(trace_index);
728 gref_serial_num = gdata->gref_serial_number_counter++;
729 io_heap_root_jni_global(object_index, gref_serial_num,
730 trace_serial_num);
731 }
732 break;
733
734 case JVMTI_HEAP_REFERENCE_SYSTEM_CLASS: {
735 char *sig;
736 SerialNumber class_serial_num;
737 SiteIndex object_site_index;
738
739 setup_tag_on_root(tag_ptr, class_tag, size,
740 gdata->unknown_thread_serial_num,
741 &object_index, &object_site_index);
742 sig = "Unknown";
743 class_serial_num = 0;
744 if ( object_site_index != 0 ) {
745 SiteKey *pkey;
746
747 pkey = get_pkey(object_site_index);
748 sig = string_get(class_get_signature(pkey->cnum));
749 class_serial_num = class_get_serial_number(pkey->cnum);
750 }
751 io_heap_root_system_class(object_index, sig, class_serial_num);
752 }
753 break;
754
755 case JVMTI_HEAP_REFERENCE_MONITOR:
756 setup_tag_on_root(tag_ptr, class_tag, size,
757 gdata->unknown_thread_serial_num,
758 &object_index, NULL);
759 io_heap_root_monitor(object_index);
760 break;
761
762 case JVMTI_HEAP_REFERENCE_STACK_LOCAL: {
763 SerialNumber thread_serial_num;
764 jlong thread_tag;
765
766 thread_tag = reference_info->stack_local.thread_tag;
767 localReference(tag_ptr, class_tag, thread_tag, size,
768 &object_index, &thread_serial_num);
769 io_heap_root_java_frame(object_index, thread_serial_num,
770 reference_info->stack_local.depth);
771 }
772 break;
773
774 case JVMTI_HEAP_REFERENCE_JNI_LOCAL: {
775 SerialNumber thread_serial_num;
776 jlong thread_tag;
777
778 thread_tag = reference_info->jni_local.thread_tag;
779 localReference(tag_ptr, class_tag, thread_tag, size,
780 &object_index, &thread_serial_num);
781 io_heap_root_jni_local(object_index, thread_serial_num,
782 reference_info->jni_local.depth);
783 }
784 break;
785
786 case JVMTI_HEAP_REFERENCE_THREAD: {
787 SerialNumber thread_serial_num;
788 SerialNumber trace_serial_num;
789 TraceIndex trace_index;
790 SiteIndex object_site_index;
791 TlsIndex tls_index;
792
793 /* It is assumed that tag_ptr is referring to a
794 * java.lang.Thread object here.
795 */
796 if ( (*tag_ptr) != (jlong)0 ) {
797 setup_tag_on_root(tag_ptr, class_tag, size, 0,
798 &object_index, &object_site_index);
799 trace_index = site_get_trace_index(object_site_index);
800 /* Hopefully the ThreadStart event put this thread's
801 * correct serial number on it's object.
802 */
803 thread_serial_num = object_get_thread_serial_number(object_index);
804 } else {
805 /* Rare situation that a Thread object is not tagged.
806 * Create special unique thread serial number in this
807 * case, probably means we never saw a thread start
808 * or thread end, or even an allocation of the thread
809 * object.
810 */
811 thread_serial_num = gdata->thread_serial_number_counter++;
812 setup_tag_on_root(tag_ptr, class_tag, size,
813 thread_serial_num,
814 &object_index, &object_site_index);
815 trace_index = gdata->system_trace_index;
816 }
817 /* Get tls_index and set in_heap_dump, if we find it. */
818 tls_index = tls_find(thread_serial_num);
819 if ( tls_index != 0 ) {
820 tls_set_in_heap_dump(tls_index, 1);
821 }
822 trace_serial_num = trace_get_serial_number(trace_index);
823 /* Issue thread object (must be before thread root) */
824 io_heap_root_thread_object(object_index,
825 thread_serial_num, trace_serial_num);
826 /* Issue thread root */
827 io_heap_root_thread(object_index, thread_serial_num);
828 }
829 break;
830
831 case JVMTI_HEAP_REFERENCE_OTHER:
832 setup_tag_on_root(tag_ptr, class_tag, size,
833 gdata->unknown_thread_serial_num,
834 &object_index, NULL);
835 io_heap_root_unknown(object_index);
836 break;
837
838 default:
839 /* Ignore anything else */
840 break;
841
842 }
843
844 return JVMTI_VISIT_OBJECTS;
845 }
846
847 void
848 site_heapdump(JNIEnv *env)
849 {
850
851 rawMonitorEnter(gdata->data_access_lock); {
852
853 jvmtiHeapCallbacks heapCallbacks;
854
855 /* Remove class dumped status, all classes must be dumped */
856 class_all_status_remove(CLASS_DUMPED);
857
858 /* Clear in_heap_dump flag */
859 tls_clear_in_heap_dump();
860
861 /* Dump the last thread traces and get the lists back we need */
862 tls_dump_traces(env);
863
864 /* Write header for heap dump */
865 io_heap_header(gdata->total_live_instances, gdata->total_live_bytes);
866
867 /* Setup a clean reference table */
868 reference_init();
869
870 /* Walk over all reachable objects and dump out roots */
871 gdata->gref_serial_number_counter = gdata->gref_serial_number_start;
872
873 /* Issue thread object for fake non-existent unknown thread
874 * just in case someone refers to it. Real threads are handled
875 * during iterate over reachable objects.
876 */
877 io_heap_root_thread_object(0, gdata->unknown_thread_serial_num,
878 trace_get_serial_number(gdata->system_trace_index));
879
880 /* Iterate over heap and get the real stuff */
881 (void)memset(&heapCallbacks, 0, sizeof(heapCallbacks));
882
883 /* Select callbacks */
884 heapCallbacks.heap_reference_callback = &cbReference;
885 if ( gdata->primfields == JNI_TRUE ) {
886 heapCallbacks.primitive_field_callback = &cbPrimFieldData;
887 }
888 if ( gdata->primarrays == JNI_TRUE ) {
889 heapCallbacks.array_primitive_value_callback = &cbPrimArrayData;
890 }
891 followReferences(&heapCallbacks, (void*)NULL);
892
893 /* Process reference information. */
894 object_reference_dump(env);
895 object_clear_references();
896 reference_cleanup();
897
898 /* Dump the last thread traces and get the lists back we need */
899 tls_dump_traces(env);
900
901 /* Write out footer for heap dump */
902 io_heap_footer();
903
904 } rawMonitorExit(gdata->data_access_lock);
905 }