?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Added the MembershipPasswordAttribute class and associated unit tests
[mono-project.git] / mono / profiler / decode.c
blob2a674e579a2910519757e86ea1ff2d71e2b4b1ea
1 /*
2 * decode.c: mprof-report program source: decode and analyze the log profiler data
3 *
4 * Author:
5 * Paolo Molaro (lupus@ximian.com)
6 *
7 * Copyright 2010 Novell, Inc (http://www.novell.com)
8 */
9 #include <config.h>
10 #include "utils.c"
11 #include "proflog.h"
12 #include <string.h>
13 #include <assert.h>
14 #include <stdio.h>
15 #if !defined(__APPLE__) && !defined(__FreeBSD__)
16 #include <malloc.h>
17 #endif
18 #include <unistd.h>
19 #include <stdlib.h>
20 #if defined (HAVE_SYS_ZLIB)
21 #include <zlib.h>
22 #endif
23 #include <glib.h>
24 #include <mono/metadata/profiler.h>
25 #include <mono/metadata/object.h>
26 #include <mono/metadata/debug-helpers.h>
27 #include <mono/utils/mono-counters.h>
28
29 #define HASH_SIZE 9371
30 #define SMALL_HASH_SIZE 31
31
32 #if defined(__native_client__) || defined(__native_client_codegen__)
33 volatile int __nacl_thread_suspension_needed = 0;
34 void __nacl_suspend_thread_if_needed() {}
35 #endif
36
37 static int debug = 0;
38 static int collect_traces = 0;
39 static int show_traces = 0;
40 static int trace_max = 6;
41 static int verbose = 0;
42 static uintptr_t *tracked_objects = 0;
43 static int num_tracked_objects = 0;
44 static uintptr_t thread_filter = 0;
45 static uint64_t find_size = 0;
46 static const char* find_name = NULL;
47 static uint64_t time_from = 0;
48 static uint64_t time_to = 0xffffffffffffffffULL;
49 static int use_time_filter = 0;
50 static uint64_t startup_time = 0;
51 static FILE* outfile = NULL;
52
53 static int32_t
54 read_int16 (unsigned char *p)
55 {
56 int32_t value = *p++;
57 value |= (*p++) << 8;
58 return value;
59 }
60
61 static int32_t
62 read_int32 (unsigned char *p)
63 {
64 int32_t value = *p++;
65 value |= (*p++) << 8;
66 value |= (*p++) << 16;
67 value |= (uint32_t)(*p++) << 24;
68 return value;
69 }
70
71 static int64_t
72 read_int64 (unsigned char *p)
73 {
74 uint64_t value = *p++;
75 value |= (*p++) << 8;
76 value |= (*p++) << 16;
77 value |= (uint64_t)(*p++) << 24;
78 value |= (uint64_t)(*p++) << 32;
79 value |= (uint64_t)(*p++) << 40;
80 value |= (uint64_t)(*p++) << 48;
81 value |= (uint64_t)(*p++) << 54;
82 return value;
83 }
84
85 static char*
86 pstrdup (const char *s)
87 {
88 int len = strlen (s) + 1;
89 char *p = malloc (len);
90 memcpy (p, s, len);
91 return p;
92 }
93
94 typedef struct _CounterValue CounterValue;
95 struct _CounterValue {
96 uint64_t timestamp;
97 unsigned char *buffer;
98 CounterValue *next;
99 };
100
101 typedef struct _Counter Counter;
102 struct _Counter {
103 int index;
104 int section;
105 const char *name;
106 int type;
107 int unit;
108 int variance;
109 CounterValue *values;
110 CounterValue *values_last;
111 };
112
113 typedef struct _CounterList CounterList;
114 struct _CounterList {
115 Counter *counter;
116 CounterList *next;
117 };
118
119 typedef struct _CounterSection CounterSection;
120 struct _CounterSection {
121 int value;
122 CounterList *counters;
123 CounterList *counters_last;
124 CounterSection *next;
125 };
126
127 typedef struct _CounterTimestamp CounterTimestamp;
128 struct _CounterTimestamp {
129 uint64_t value;
130 CounterSection *sections;
131 CounterSection *sections_last;
132 CounterTimestamp *next;
133 };
134
135 static CounterList *counters = NULL;
136 static CounterSection *counters_sections = NULL;
137 static CounterTimestamp *counters_timestamps = NULL;
138
139 enum {
140 COUNTERS_SORT_TIME,
141 COUNTERS_SORT_CATEGORY
142 };
143
144 static int counters_sort_mode = COUNTERS_SORT_TIME;
145
146 static void
147 add_counter_to_section (Counter *counter)
148 {
149 CounterSection *csection, *s;
150 CounterList *clist;
151
152 clist = calloc (1, sizeof (CounterList));
153 clist->counter = counter;
154
155 for (csection = counters_sections; csection; csection = csection->next) {
156 if (csection->value == counter->section) {
157 /* If section exist */
158 if (!csection->counters)
159 csection->counters = clist;
160 else
161 csection->counters_last->next = clist;
162 csection->counters_last = clist;
163 return;
164 }
165 }
166
167 /* If section does not exist */
168 csection = calloc (1, sizeof (CounterSection));
169 csection->value = counter->section;
170 csection->counters = clist;
171 csection->counters_last = clist;
172
173 if (!counters_sections) {
174 counters_sections = csection;
175 } else {
176 s = counters_sections;
177 while (s->next)
178 s = s->next;
179 s->next = csection;
180 }
181 }
182
183 static void
184 add_counter (int section, const char *name, int type, int unit, int variance, int index)
185 {
186 CounterList *list, *l;
187 Counter *counter;
188
189 for (list = counters; list; list = list->next)
190 if (list->counter->index == index)
191 return;
192
193 counter = calloc (1, sizeof (Counter));
194 counter->section = section;
195 counter->name = name;
196 counter->type = type;
197 counter->unit = unit;
198 counter->variance = variance;
199 counter->index = index;
200
201 list = calloc (1, sizeof (CounterList));
202 list->counter = counter;
203
204 if (!counters) {
205 counters = list;
206 } else {
207 l = counters;
208 while (l->next)
209 l = l->next;
210 l->next = list;
211 }
212
213 if (counters_sort_mode == COUNTERS_SORT_CATEGORY || !verbose)
214 add_counter_to_section (counter);
215 }
216
217 static void
218 add_counter_to_timestamp (uint64_t timestamp, Counter *counter)
219 {
220 CounterTimestamp *ctimestamp, *t;
221 CounterSection *csection;
222 CounterList *clist;
223
224 clist = calloc (1, sizeof (CounterList));
225 clist->counter = counter;
226
227 for (ctimestamp = counters_timestamps; ctimestamp; ctimestamp = ctimestamp->next) {
228 if (ctimestamp->value == timestamp) {
229 for (csection = ctimestamp->sections; csection; csection = csection->next) {
230 if (csection->value == counter->section) {
231 /* if timestamp exist and section exist */
232 if (!csection->counters)
233 csection->counters = clist;
234 else
235 csection->counters_last->next = clist;
236 csection->counters_last = clist;
237 return;
238 }
239 }
240
241 /* if timestamp exist and section does not exist */
242 csection = calloc (1, sizeof (CounterSection));
243 csection->value = counter->section;
244 csection->counters = clist;
245 csection->counters_last = clist;
246
247 if (!ctimestamp->sections)
248 ctimestamp->sections = csection;
249 else
250 ctimestamp->sections_last->next = csection;
251 ctimestamp->sections_last = csection;
252 return;
253 }
254 }
255
256 /* If timestamp do not exist and section does not exist */
257 csection = calloc (1, sizeof (CounterSection));
258 csection->value = counter->section;
259 csection->counters = clist;
260 csection->counters_last = clist;
261
262 ctimestamp = calloc (1, sizeof (CounterTimestamp));
263 ctimestamp->value = timestamp;
264 ctimestamp->sections = csection;
265 ctimestamp->sections_last = csection;
266
267 if (!counters_timestamps) {
268 counters_timestamps = ctimestamp;
269 } else {
270 t = counters_timestamps;
271 while (t->next)
272 t = t->next;
273 t->next = ctimestamp;
274 }
275 }
276
277 static void
278 add_counter_value (int index, CounterValue *value)
279 {
280 CounterList *list;
281
282 for (list = counters; list; list = list->next) {
283 if (list->counter->index == index) {
284 if (!list->counter->values)
285 list->counter->values = value;
286 else
287 list->counter->values_last->next = value;
288 list->counter->values_last = value;
289
290 if (counters_sort_mode == COUNTERS_SORT_TIME)
291 add_counter_to_timestamp (value->timestamp, list->counter);
292
293 return;
294 }
295 }
296 }
297
298 static const char*
299 section_name (int section)
300 {
301 switch (section) {
302 case MONO_COUNTER_JIT: return "Mono JIT";
303 case MONO_COUNTER_GC: return "Mono GC";
304 case MONO_COUNTER_METADATA: return "Mono Metadata";
305 case MONO_COUNTER_GENERICS: return "Mono Generics";
306 case MONO_COUNTER_SECURITY: return "Mono Security";
307 case MONO_COUNTER_RUNTIME: return "Mono Runtime";
308 case MONO_COUNTER_SYSTEM: return "Mono System";
309 default: return "<unknown>";
310 }
311 }
312
313 static const char*
314 type_name (int type)
315 {
316 switch (type) {
317 case MONO_COUNTER_INT: return "Int";
318 case MONO_COUNTER_UINT: return "UInt";
319 case MONO_COUNTER_WORD: return "Word";
320 case MONO_COUNTER_LONG: return "Long";
321 case MONO_COUNTER_ULONG: return "ULong";
322 case MONO_COUNTER_DOUBLE: return "Double";
323 case MONO_COUNTER_STRING: return "String";
324 case MONO_COUNTER_TIME_INTERVAL: return "Time Interval";
325 default: return "<unknown>";
326 }
327 }
328
329 static const char*
330 unit_name (int unit)
331 {
332 switch (unit) {
333 case MONO_COUNTER_RAW: return "Raw";
334 case MONO_COUNTER_BYTES: return "Bytes";
335 case MONO_COUNTER_TIME: return "Time";
336 case MONO_COUNTER_COUNT: return "Count";
337 case MONO_COUNTER_PERCENTAGE: return "Percentage";
338 default: return "<unknown>";
339 }
340 }
341
342 static const char*
343 variance_name (int variance)
344 {
345 switch (variance) {
346 case MONO_COUNTER_MONOTONIC: return "Monotonic";
347 case MONO_COUNTER_CONSTANT: return "Constant";
348 case MONO_COUNTER_VARIABLE: return "Variable";
349 default: return "<unknown>";
350 }
351 }
352
353 static void
354 dump_counters_value (Counter *counter, const char *key_format, const char *key, void *value)
355 {
356 char format[32];
357
358 if (value == NULL) {
359 snprintf (format, sizeof (format), "%s : %%s\n", key_format);
360 fprintf (outfile, format, key, "<null>");
361 } else {
362 switch (counter->type) {
363 case MONO_COUNTER_INT:
364 #if SIZEOF_VOID_P == 4
365 case MONO_COUNTER_WORD:
366 #endif
367 snprintf (format, sizeof (format), "%s : %%d\n", key_format);
368 fprintf (outfile, format, key, *(int32_t*)value);
369 break;
370 case MONO_COUNTER_UINT:
371 snprintf (format, sizeof (format), "%s : %%u\n", key_format);
372 fprintf (outfile, format, key, *(uint32_t*)value);
373 break;
374 case MONO_COUNTER_LONG:
375 #if SIZEOF_VOID_P == 8
376 case MONO_COUNTER_WORD:
377 #endif
378 case MONO_COUNTER_TIME_INTERVAL:
379 if (counter->type == MONO_COUNTER_LONG && counter->unit == MONO_COUNTER_TIME) {
380 snprintf (format, sizeof (format), "%s : %%0.3fms\n", key_format);
381 fprintf (outfile, format, key, (double)*(int64_t*)value / 10000.0);
382 } else if (counter->type == MONO_COUNTER_TIME_INTERVAL) {
383 snprintf (format, sizeof (format), "%s : %%0.3fms\n", key_format);
384 fprintf (outfile, format, key, (double)*(int64_t*)value / 1000.0);
385 } else {
386 snprintf (format, sizeof (format), "%s : %%u\n", key_format);
387 fprintf (outfile, format, key, *(int64_t*)value);
388 }
389 break;
390 case MONO_COUNTER_ULONG:
391 snprintf (format, sizeof (format), "%s : %%llu\n", key_format);
392 fprintf (outfile, format, key, *(uint64_t*)value);
393 break;
394 case MONO_COUNTER_DOUBLE:
395 snprintf (format, sizeof (format), "%s : %%f\n", key_format);
396 fprintf (outfile, format, key, *(double*)value);
397 break;
398 case MONO_COUNTER_STRING:
399 snprintf (format, sizeof (format), "%s : %%s\n", key_format);
400 fprintf (outfile, format, key, *(char*)value);
401 break;
402 }
403 }
404 }
405
406 static void
407 dump_counters (void)
408 {
409 Counter *counter;
410 CounterValue *cvalue;
411 CounterTimestamp *ctimestamp;
412 CounterSection *csection;
413 CounterList *clist;
414 char strtimestamp[17];
415 int i, section_printed;
416
417 fprintf (outfile, "\nCounters:\n");
418
419 if (!verbose) {
420 char counters_to_print[][64] = {
421 "Methods from AOT",
422 "Methods JITted using mono JIT",
423 "Methods JITted using LLVM",
424 "Total time spent JITting (sec)",
425 "User Time",
426 "System Time",
427 "Total Time",
428 "Working Set",
429 "Private Bytes",
430 "Virtual Bytes",
431 "Page Faults",
432 "CPU Load Average - 1min",
433 "CPU Load Average - 5min",
434 "CPU Load Average - 15min",
435 ""
436 };
437
438 for (csection = counters_sections; csection; csection = csection->next) {
439 section_printed = 0;
440
441 for (clist = csection->counters; clist; clist = clist->next) {
442 counter = clist->counter;
443 if (!counter->values_last)
444 continue;
445
446 for (i = 0; counters_to_print [i][0] != 0; i++) {
447 if (strcmp (counters_to_print [i], counter->name) == 0) {
448 if (!section_printed) {
449 fprintf (outfile, "\t%s:\n", section_name (csection->value));
450 section_printed = 1;
451 }
452
453 dump_counters_value (counter, "\t\t%-30s", counter->name, counter->values_last->buffer);
454 break;
455 }
456 }
457 }
458 }
459 } else if (counters_sort_mode == COUNTERS_SORT_TIME) {
460 for (ctimestamp = counters_timestamps; ctimestamp; ctimestamp = ctimestamp->next) {
461 fprintf (outfile, "\t%llu:%02llu:%02llu:%02llu.%03llu:\n",
462 (unsigned long long) (ctimestamp->value / 1000 / 60 / 60 / 24 % 1000),
463 (unsigned long long) (ctimestamp->value / 1000 / 60 / 60 % 24),
464 (unsigned long long) (ctimestamp->value / 1000 / 60 % 60),
465 (unsigned long long) (ctimestamp->value / 1000 % 60),
466 (unsigned long long) (ctimestamp->value % 1000));
467
468 for (csection = ctimestamp->sections; csection; csection = csection->next) {
469 fprintf (outfile, "\t\t%s:\n", section_name (csection->value));
470
471 for (clist = csection->counters; clist; clist = clist->next) {
472 counter = clist->counter;
473 for (cvalue = counter->values; cvalue; cvalue = cvalue->next) {
474 if (cvalue->timestamp != ctimestamp->value)
475 continue;
476
477 dump_counters_value (counter, "\t\t\t%-30s", counter->name, cvalue->buffer);
478 }
479 }
480 }
481 }
482 } else if (counters_sort_mode == COUNTERS_SORT_CATEGORY) {
483 for (csection = counters_sections; csection; csection = csection->next) {
484 fprintf (outfile, "\t%s:\n", section_name (csection->value));
485
486 for (clist = csection->counters; clist; clist = clist->next) {
487 counter = clist->counter;
488 fprintf (outfile, "\t\t%s: [type: %s, unit: %s, variance: %s]\n",
489 counter->name, type_name (counter->type), unit_name (counter->unit), variance_name (counter->variance));
490
491 for (cvalue = counter->values; cvalue; cvalue = cvalue->next) {
492 snprintf (strtimestamp, sizeof (strtimestamp), "%llu:%02llu:%02llu:%02llu.%03llu",
493 (unsigned long long) (cvalue->timestamp / 1000 / 60 / 60 / 24 % 1000),
494 (unsigned long long) (cvalue->timestamp / 1000 / 60 / 60 % 24),
495 (unsigned long long) (cvalue->timestamp / 1000 / 60 % 60),
496 (unsigned long long) (cvalue->timestamp / 1000 % 60),
497 (unsigned long long) (cvalue->timestamp % 1000));
498
499 dump_counters_value (counter, "\t\t\t%s", strtimestamp, cvalue->buffer);
500 }
501 }
502 }
503 }
504 }
505
506 static int num_images;
507 typedef struct _ImageDesc ImageDesc;
508 struct _ImageDesc {
509 ImageDesc *next;
510 intptr_t image;
511 char *filename;
512 };
513
514 static ImageDesc* image_hash [SMALL_HASH_SIZE] = {0};
515
516 static void
517 add_image (intptr_t image, char *name)
518 {
519 int slot = ((image >> 2) & 0xffff) % SMALL_HASH_SIZE;
520 ImageDesc *cd = malloc (sizeof (ImageDesc));
521 cd->image = image;
522 cd->filename = pstrdup (name);
523 cd->next = image_hash [slot];
524 image_hash [slot] = cd;
525 num_images++;
526 }
527
528 typedef struct _BackTrace BackTrace;
529 typedef struct {
530 uint64_t count;
531 BackTrace *bt;
532 } CallContext;
533
534 typedef struct {
535 int count;
536 int size;
537 CallContext *traces;
538 } TraceDesc;
539
540 typedef struct _ClassDesc ClassDesc;
541 struct _ClassDesc {
542 ClassDesc *next;
543 intptr_t klass;
544 char *name;
545 intptr_t allocs;
546 uint64_t alloc_size;
547 TraceDesc traces;
548 };
549
550 static ClassDesc* class_hash [HASH_SIZE] = {0};
551 static int num_classes = 0;
552
553 static ClassDesc*
554 add_class (intptr_t klass, const char *name)
555 {
556 int slot = ((klass >> 2) & 0xffff) % HASH_SIZE;
557 ClassDesc *cd;
558 cd = class_hash [slot];
559 while (cd && cd->klass != klass)
560 cd = cd->next;
561 /* we resolved an unknown class (unless we had the code unloaded) */
562 if (cd) {
563 /*printf ("resolved unknown: %s\n", name);*/
564 free (cd->name);
565 cd->name = pstrdup (name);
566 return cd;
567 }
568 cd = calloc (sizeof (ClassDesc), 1);
569 cd->klass = klass;
570 cd->name = pstrdup (name);
571 cd->next = class_hash [slot];
572 cd->allocs = 0;
573 cd->alloc_size = 0;
574 cd->traces.count = 0;
575 cd->traces.size = 0;
576 cd->traces.traces = NULL;
577 class_hash [slot] = cd;
578 num_classes++;
579 return cd;
580 }
581
582 static ClassDesc *
583 lookup_class (intptr_t klass)
584 {
585 int slot = ((klass >> 2) & 0xffff) % HASH_SIZE;
586 ClassDesc *cd = class_hash [slot];
587 while (cd && cd->klass != klass)
588 cd = cd->next;
589 if (!cd) {
590 char buf [128];
591 snprintf (buf, sizeof (buf), "unresolved class %p", (void*)klass);
592 return add_class (klass, buf);
593 }
594 return cd;
595 }
596
597 typedef struct _MethodDesc MethodDesc;
598 struct _MethodDesc {
599 MethodDesc *next;
600 intptr_t method;
601 char *name;
602 intptr_t code;
603 int len;
604 int recurse_count;
605 int sample_hits;
606 int ignore_jit; /* when this is set, we collect the metadata but don't count this method fot jit time and code size, when filtering events */
607 uint64_t calls;
608 uint64_t total_time;
609 uint64_t callee_time;
610 uint64_t self_time;
611 TraceDesc traces;
612 };
613
614 static MethodDesc* method_hash [HASH_SIZE] = {0};
615 static int num_methods = 0;
616
617 static MethodDesc*
618 add_method (intptr_t method, const char *name, intptr_t code, int len)
619 {
620 int slot = ((method >> 2) & 0xffff) % HASH_SIZE;
621 MethodDesc *cd;
622 cd = method_hash [slot];
623 while (cd && cd->method != method)
624 cd = cd->next;
625 /* we resolved an unknown method (unless we had the code unloaded) */
626 if (cd) {
627 cd->code = code;
628 cd->len = len;
629 /*printf ("resolved unknown: %s\n", name);*/
630 free (cd->name);
631 cd->name = pstrdup (name);
632 return cd;
633 }
634 cd = calloc (sizeof (MethodDesc), 1);
635 cd->method = method;
636 cd->name = pstrdup (name);
637 cd->code = code;
638 cd->len = len;
639 cd->calls = 0;
640 cd->total_time = 0;
641 cd->traces.count = 0;
642 cd->traces.size = 0;
643 cd->traces.traces = NULL;
644 cd->next = method_hash [slot];
645 method_hash [slot] = cd;
646 num_methods++;
647 return cd;
648 }
649
650 static MethodDesc *
651 lookup_method (intptr_t method)
652 {
653 int slot = ((method >> 2) & 0xffff) % HASH_SIZE;
654 MethodDesc *cd = method_hash [slot];
655 while (cd && cd->method != method)
656 cd = cd->next;
657 if (!cd) {
658 char buf [128];
659 snprintf (buf, sizeof (buf), "unknown method %p", (void*)method);
660 return add_method (method, buf, 0, 0);
661 }
662 return cd;
663 }
664
665 static int num_stat_samples = 0;
666 static int size_stat_samples = 0;
667 uintptr_t *stat_samples = NULL;
668 int *stat_sample_desc = NULL;
669
670 static void
671 add_stat_sample (int type, uintptr_t ip) {
672 if (num_stat_samples == size_stat_samples) {
673 size_stat_samples *= 2;
674 if (!size_stat_samples)
675 size_stat_samples = 32;
676 stat_samples = realloc (stat_samples, size_stat_samples * sizeof (uintptr_t));
677 stat_sample_desc = realloc (stat_sample_desc, size_stat_samples * sizeof (int));
678 }
679 stat_samples [num_stat_samples] = ip;
680 stat_sample_desc [num_stat_samples++] = type;
681 }
682
683 static MethodDesc*
684 lookup_method_by_ip (uintptr_t ip)
685 {
686 int i;
687 MethodDesc* m;
688 /* dumb */
689 for (i = 0; i < HASH_SIZE; ++i) {
690 m = method_hash [i];
691 while (m) {
692 //printf ("checking %p against %p-%p\n", (void*)ip, (void*)(m->code), (void*)(m->code + m->len));
693 if (ip >= (uintptr_t)m->code && ip < (uintptr_t)m->code + m->len) {
694 return m;
695 }
696 m = m->next;
697 }
698 }
699 return NULL;
700 }
701
702 static int
703 compare_method_samples (const void *a, const void *b)
704 {
705 MethodDesc *const*A = a;
706 MethodDesc *const*B = b;
707 if ((*A)->sample_hits == (*B)->sample_hits)
708 return 0;
709 if ((*B)->sample_hits < (*A)->sample_hits)
710 return -1;
711 return 1;
712 }
713
714 typedef struct _UnmanagedSymbol UnmanagedSymbol;
715 struct _UnmanagedSymbol {
716 UnmanagedSymbol *parent;
717 char *name;
718 int is_binary;
719 uintptr_t addr;
720 uintptr_t size;
721 uintptr_t sample_hits;
722 };
723
724 static UnmanagedSymbol **usymbols = NULL;
725 static int usymbols_size = 0;
726 static int usymbols_num = 0;
727
728 static int
729 compare_usymbol_addr (const void *a, const void *b)
730 {
731 UnmanagedSymbol *const*A = a;
732 UnmanagedSymbol *const*B = b;
733 if ((*B)->addr == (*A)->addr)
734 return 0;
735 if ((*B)->addr > (*A)->addr)
736 return -1;
737 return 1;
738 }
739
740 static int
741 compare_usymbol_samples (const void *a, const void *b)
742 {
743 UnmanagedSymbol *const*A = a;
744 UnmanagedSymbol *const*B = b;
745 if ((*B)->sample_hits == (*A)->sample_hits)
746 return 0;
747 if ((*B)->sample_hits < (*A)->sample_hits)
748 return -1;
749 return 1;
750 }
751
752 static void
753 add_unmanaged_symbol (uintptr_t addr, char *name, uintptr_t size)
754 {
755 UnmanagedSymbol *sym;
756 if (usymbols_num == usymbols_size) {
757 int new_size = usymbols_size * 2;
758 if (!new_size)
759 new_size = 16;
760 usymbols = realloc (usymbols, sizeof (void*) * new_size);
761 usymbols_size = new_size;
762 }
763 sym = calloc (sizeof (UnmanagedSymbol), 1);
764 sym->addr = addr;
765 sym->name = name;
766 sym->size = size;
767 usymbols [usymbols_num++] = sym;
768 }
769
770 /* only valid after the symbols are sorted */
771 static UnmanagedSymbol*
772 lookup_unmanaged_symbol (uintptr_t addr)
773 {
774 int r = usymbols_num - 1;
775 int l = 0;
776 UnmanagedSymbol *sym;
777 int last_best = -1;
778 while (r >= l) {
779 int m = (l + r) / 2;
780 sym = usymbols [m];
781 if (addr == sym->addr)
782 return sym;
783 if (addr < sym->addr) {
784 r = m - 1;
785 } else if (addr > sym->addr) {
786 l = m + 1;
787 last_best = m;
788 }
789 }
790 if (last_best >= 0 && (addr - usymbols [last_best]->addr) < 4096)
791 return usymbols [last_best];
792 return NULL;
793 }
794
795 /* we use the same structure for binaries */
796 static UnmanagedSymbol **ubinaries = NULL;
797 static int ubinaries_size = 0;
798 static int ubinaries_num = 0;
799
800 static void
801 add_unmanaged_binary (uintptr_t addr, char *name, uintptr_t size)
802 {
803 UnmanagedSymbol *sym;
804 if (ubinaries_num == ubinaries_size) {
805 int new_size = ubinaries_size * 2;
806 if (!new_size)
807 new_size = 16;
808 ubinaries = realloc (ubinaries, sizeof (void*) * new_size);
809 ubinaries_size = new_size;
810 }
811 sym = calloc (sizeof (UnmanagedSymbol), 1);
812 sym->addr = addr;
813 sym->name = name;
814 sym->size = size;
815 sym->is_binary = 1;
816 ubinaries [ubinaries_num++] = sym;
817 }
818
819 static UnmanagedSymbol*
820 lookup_unmanaged_binary (uintptr_t addr)
821 {
822 int i;
823 for (i = 0; i < ubinaries_num; ++i) {
824 UnmanagedSymbol *ubin = ubinaries [i];
825 if (addr >= ubin->addr && addr < ubin->addr + ubin->size) {
826 return ubin;
827 }
828 }
829 return NULL;
830 }
831
832 static const char*
833 sample_type_name (int type)
834 {
835 switch (type) {
836 case SAMPLE_CYCLES: return "cycles";
837 case SAMPLE_INSTRUCTIONS: return "instructions retired";
838 case SAMPLE_CACHE_MISSES: return "cache misses";
839 case SAMPLE_CACHE_REFS: return "cache references";
840 case SAMPLE_BRANCHES: return "executed branches";
841 case SAMPLE_BRANCH_MISSES: return "unpredicted branches";
842 }
843 return "unknown";
844 }
845
846 static void
847 set_usym_parent (UnmanagedSymbol** cachedus, int count)
848 {
849 int i;
850 for (i = 0; i < count; ++i) {
851 UnmanagedSymbol *ubin = lookup_unmanaged_binary (cachedus [i]->addr);
852 if (ubin == cachedus [i])
853 continue;
854 cachedus [i]->parent = ubin;
855 }
856 }
857
858 static void
859 print_usym (UnmanagedSymbol* um)
860 {
861 if (um->parent)
862 fprintf (outfile, "\t%6zd %6.2f %-36s in %s\n", um->sample_hits, um->sample_hits*100.0/num_stat_samples, um->name, um->parent->name);
863 else
864 fprintf (outfile, "\t%6zd %6.2f %s\n", um->sample_hits, um->sample_hits*100.0/num_stat_samples, um->name);
865 }
866
867 static int
868 sym_percent (uintptr_t sample_hits)
869 {
870 double pc;
871 if (verbose)
872 return 1;
873 pc = sample_hits*100.0/num_stat_samples;
874 return pc >= 0.1;
875 }
876
877 static void
878 dump_samples (void)
879 {
880 int i, u;
881 int count = 0, msize = 0;
882 int unmanaged_hits = 0;
883 int unresolved_hits = 0;
884 MethodDesc** cachedm = NULL;
885 int ucount = 0, usize = 0;
886 UnmanagedSymbol** cachedus = NULL;
887 if (!num_stat_samples)
888 return;
889 qsort (usymbols, usymbols_num, sizeof (UnmanagedSymbol*), compare_usymbol_addr);
890 for (i = 0; i < num_stat_samples; ++i) {
891 MethodDesc *m = lookup_method_by_ip (stat_samples [i]);
892 if (m) {
893 if (!m->sample_hits) {
894 if (count == msize) {
895 msize *= 2;
896 if (!msize)
897 msize = 4;
898 cachedm = realloc (cachedm, sizeof (void*) * msize);
899 }
900 cachedm [count++] = m;
901 }
902 m->sample_hits++;
903 } else {
904 UnmanagedSymbol *usym = lookup_unmanaged_symbol (stat_samples [i]);
905 if (!usym) {
906 unresolved_hits++;
907 //printf ("unmanaged hit at %p\n", (void*)stat_samples [i]);
908 usym = lookup_unmanaged_binary (stat_samples [i]);
909 }
910 if (usym) {
911 if (!usym->sample_hits) {
912 if (ucount == usize) {
913 usize *= 2;
914 if (!usize)
915 usize = 4;
916 cachedus = realloc (cachedus, sizeof (void*) * usize);
917 }
918 cachedus [ucount++] = usym;
919 }
920 usym->sample_hits++;
921 }
922 unmanaged_hits++;
923 }
924 }
925 qsort (cachedm, count, sizeof (MethodDesc*), compare_method_samples);
926 qsort (cachedus, ucount, sizeof (UnmanagedSymbol*), compare_usymbol_samples);
927 set_usym_parent (cachedus, ucount);
928 fprintf (outfile, "\nStatistical samples summary\n");
929 fprintf (outfile, "\tSample type: %s\n", sample_type_name (stat_sample_desc [0]));
930 fprintf (outfile, "\tUnmanaged hits: %6d (%4.1f%%)\n", unmanaged_hits, (100.0*unmanaged_hits)/num_stat_samples);
931 fprintf (outfile, "\tManaged hits: %6d (%4.1f%%)\n", num_stat_samples - unmanaged_hits, (100.0*(num_stat_samples-unmanaged_hits))/num_stat_samples);
932 fprintf (outfile, "\tUnresolved hits: %6d (%4.1f%%)\n", unresolved_hits, (100.0*unresolved_hits)/num_stat_samples);
933 fprintf (outfile, "\t%6s %6s %s\n", "Hits", "%", "Method name");
934 i = 0;
935 u = 0;
936 while (i < count || u < ucount) {
937 if (i < count) {
938 MethodDesc *m = cachedm [i];
939 if (u < ucount) {
940 UnmanagedSymbol *um = cachedus [u];
941 if (um->sample_hits > m->sample_hits) {
942 if (!sym_percent (um->sample_hits))
943 break;
944 print_usym (um);
945 u++;
946 continue;
947 }
948 }
949 if (!sym_percent (m->sample_hits))
950 break;
951 fprintf (outfile, "\t%6d %6.2f %s\n", m->sample_hits, m->sample_hits*100.0/num_stat_samples, m->name);
952 i++;
953 continue;
954 }
955 if (u < ucount) {
956 UnmanagedSymbol *um = cachedus [u];
957 if (!sym_percent (um->sample_hits))
958 break;
959 print_usym (um);
960 u++;
961 continue;
962 }
963 }
964 }
965
966 typedef struct _HeapClassDesc HeapClassDesc;
967 typedef struct {
968 HeapClassDesc *klass;
969 uint64_t count;
970 } HeapClassRevRef;
971
972 struct _HeapClassDesc {
973 ClassDesc *klass;
974 int64_t count;
975 int64_t total_size;
976 HeapClassRevRef *rev_hash;
977 int rev_hash_size;
978 int rev_count;
979 uintptr_t pinned_references;
980 uintptr_t root_references;
981 };
982
983 static int
984 add_rev_class_hashed (HeapClassRevRef *rev_hash, uintptr_t size, HeapClassDesc *hklass, uint64_t value)
985 {
986 uintptr_t i;
987 uintptr_t start_pos;
988 start_pos = (hklass->klass->klass >> 2) % size;
989 assert (start_pos < size);
990 i = start_pos;
991 do {
992 if (rev_hash [i].klass == hklass) {
993 rev_hash [i].count += value;
994 return 0;
995 } else if (!rev_hash [i].klass) {
996 rev_hash [i].klass = hklass;
997 rev_hash [i].count += value;
998 start_pos = 0;
999 for (i = 0; i < size; ++i)
1000 if (rev_hash [i].klass && rev_hash [i].klass->klass == hklass->klass)
1001 start_pos ++;
1002 assert (start_pos == 1);
1003 return 1;
1004 }
1005 /* wrap around */
1006 if (++i == size)
1007 i = 0;
1008 } while (i != start_pos);
1009 /* should not happen */
1010 printf ("failed revref store\n");
1011 return 0;
1012 }
1013
1014 static void
1015 add_heap_class_rev (HeapClassDesc *from, HeapClassDesc *to)
1016 {
1017 uintptr_t i;
1018 if (to->rev_count * 2 >= to->rev_hash_size) {
1019 HeapClassRevRef *n;
1020 uintptr_t old_size = to->rev_hash_size;
1021 to->rev_hash_size *= 2;
1022 if (to->rev_hash_size == 0)
1023 to->rev_hash_size = 4;
1024 n = calloc (sizeof (HeapClassRevRef) * to->rev_hash_size, 1);
1025 for (i = 0; i < old_size; ++i) {
1026 if (to->rev_hash [i].klass)
1027 add_rev_class_hashed (n, to->rev_hash_size, to->rev_hash [i].klass, to->rev_hash [i].count);
1028 }
1029 if (to->rev_hash)
1030 free (to->rev_hash);
1031 to->rev_hash = n;
1032 }
1033 to->rev_count += add_rev_class_hashed (to->rev_hash, to->rev_hash_size, from, 1);
1034 }
1035
1036 typedef struct {
1037 uintptr_t objaddr;
1038 HeapClassDesc *hklass;
1039 uintptr_t num_refs;
1040 uintptr_t refs [0];
1041 } HeapObjectDesc;
1042
1043 typedef struct _HeapShot HeapShot;
1044 struct _HeapShot {
1045 HeapShot *next;
1046 uint64_t timestamp;
1047 int class_count;
1048 int hash_size;
1049 HeapClassDesc **class_hash;
1050 HeapClassDesc **sorted;
1051 HeapObjectDesc **objects_hash;
1052 uintptr_t objects_count;
1053 uintptr_t objects_hash_size;
1054 uintptr_t num_roots;
1055 uintptr_t *roots;
1056 uintptr_t *roots_extra;
1057 int *roots_types;
1058 };
1059
1060 static HeapShot *heap_shots = NULL;
1061 static int num_heap_shots = 0;
1062
1063 static HeapShot*
1064 new_heap_shot (uint64_t timestamp)
1065 {
1066 HeapShot *hs = calloc (sizeof (HeapShot), 1);
1067 hs->hash_size = 4;
1068 hs->class_hash = calloc (sizeof (void*), hs->hash_size);
1069 hs->timestamp = timestamp;
1070 num_heap_shots++;
1071 hs->next = heap_shots;
1072 heap_shots = hs;
1073 return hs;
1074 }
1075
1076 static HeapClassDesc*
1077 heap_class_lookup (HeapShot *hs, ClassDesc *klass)
1078 {
1079 int i;
1080 unsigned int start_pos;
1081 start_pos = ((uintptr_t)klass->klass >> 2) % hs->hash_size;
1082 i = start_pos;
1083 do {
1084 HeapClassDesc* cd = hs->class_hash [i];
1085 if (!cd)
1086 return NULL;
1087 if (cd->klass == klass)
1088 return cd;
1089 /* wrap around */
1090 if (++i == hs->hash_size)
1091 i = 0;
1092 } while (i != start_pos);
1093 return NULL;
1094 }
1095
1096 static int
1097 add_heap_hashed (HeapClassDesc **hash, HeapClassDesc **retv, uintptr_t hsize, ClassDesc *klass, uint64_t size, uint64_t count)
1098 {
1099 uintptr_t i;
1100 uintptr_t start_pos;
1101 start_pos = ((uintptr_t)klass->klass >> 2) % hsize;
1102 i = start_pos;
1103 do {
1104 if (hash [i] && hash [i]->klass == klass) {
1105 hash [i]->total_size += size;
1106 hash [i]->count += count;
1107 *retv = hash [i];
1108 return 0;
1109 } else if (!hash [i]) {
1110 if (*retv) {
1111 hash [i] = *retv;
1112 return 1;
1113 }
1114 hash [i] = calloc (sizeof (HeapClassDesc), 1);
1115 hash [i]->klass = klass;
1116 hash [i]->total_size += size;
1117 hash [i]->count += count;
1118 *retv = hash [i];
1119 return 1;
1120 }
1121 /* wrap around */
1122 if (++i == hsize)
1123 i = 0;
1124 } while (i != start_pos);
1125 /* should not happen */
1126 printf ("failed heap class store\n");
1127 return 0;
1128 }
1129
1130 static HeapClassDesc*
1131 add_heap_shot_class (HeapShot *hs, ClassDesc *klass, uint64_t size)
1132 {
1133 HeapClassDesc *res;
1134 int i;
1135 if (hs->class_count * 2 >= hs->hash_size) {
1136 HeapClassDesc **n;
1137 int old_size = hs->hash_size;
1138 hs->hash_size *= 2;
1139 if (hs->hash_size == 0)
1140 hs->hash_size = 4;
1141 n = calloc (sizeof (void*) * hs->hash_size, 1);
1142 for (i = 0; i < old_size; ++i) {
1143 res = hs->class_hash [i];
1144 if (hs->class_hash [i])
1145 add_heap_hashed (n, &res, hs->hash_size, hs->class_hash [i]->klass, hs->class_hash [i]->total_size, hs->class_hash [i]->count);
1146 }
1147 if (hs->class_hash)
1148 free (hs->class_hash);
1149 hs->class_hash = n;
1150 }
1151 res = NULL;
1152 hs->class_count += add_heap_hashed (hs->class_hash, &res, hs->hash_size, klass, size, 1);
1153 //if (res->count == 1)
1154 // printf ("added heap class: %s\n", res->klass->name);
1155 return res;
1156 }
1157
1158 static HeapObjectDesc*
1159 alloc_heap_obj (uintptr_t objaddr, HeapClassDesc *hklass, uintptr_t num_refs)
1160 {
1161 HeapObjectDesc* ho = calloc (sizeof (HeapObjectDesc) + num_refs * sizeof (uintptr_t), 1);
1162 ho->objaddr = objaddr;
1163 ho->hklass = hklass;
1164 ho->num_refs = num_refs;
1165 return ho;
1166 }
1167
1168 static uintptr_t
1169 heap_shot_find_obj_slot (HeapShot *hs, uintptr_t objaddr)
1170 {
1171 uintptr_t i;
1172 uintptr_t start_pos;
1173 HeapObjectDesc **hash = hs->objects_hash;
1174 start_pos = ((uintptr_t)objaddr >> 3) % hs->objects_hash_size;
1175 i = start_pos;
1176 do {
1177 if (hash [i] && hash [i]->objaddr == objaddr) {
1178 return i;
1179 } else if (!hash [i]) {
1180 break; /* fail */
1181 }
1182 /* wrap around */
1183 if (++i == hs->objects_hash_size)
1184 i = 0;
1185 } while (i != start_pos);
1186 /* should not happen */
1187 //printf ("failed heap obj slot\n");
1188 return -1;
1189 }
1190
1191 static HeapObjectDesc*
1192 heap_shot_obj_add_refs (HeapShot *hs, uintptr_t objaddr, uintptr_t num, uintptr_t *ref_offset)
1193 {
1194 HeapObjectDesc **hash = hs->objects_hash;
1195 uintptr_t i = heap_shot_find_obj_slot (hs, objaddr);
1196 if (i >= 0) {
1197 HeapObjectDesc* ho = alloc_heap_obj (objaddr, hash [i]->hklass, hash [i]->num_refs + num);
1198 *ref_offset = hash [i]->num_refs;
1199 memcpy (ho->refs, hash [i]->refs, hash [i]->num_refs * sizeof (uintptr_t));
1200 free (hash [i]);
1201 hash [i] = ho;
1202 return ho;
1203 }
1204 /* should not happen */
1205 printf ("failed heap obj update\n");
1206 return NULL;
1207
1208 }
1209
1210 static uintptr_t
1211 add_heap_hashed_obj (HeapObjectDesc **hash, uintptr_t hsize, HeapObjectDesc *obj)
1212 {
1213 uintptr_t i;
1214 uintptr_t start_pos;
1215 start_pos = ((uintptr_t)obj->objaddr >> 3) % hsize;
1216 i = start_pos;
1217 do {
1218 if (hash [i] && hash [i]->objaddr == obj->objaddr) {
1219 printf ("duplicate object!\n");
1220 return 0;
1221 } else if (!hash [i]) {
1222 hash [i] = obj;
1223 return 1;
1224 }
1225 /* wrap around */
1226 if (++i == hsize)
1227 i = 0;
1228 } while (i != start_pos);
1229 /* should not happen */
1230 printf ("failed heap obj store\n");
1231 return 0;
1232 }
1233
1234 static void
1235 add_heap_shot_obj (HeapShot *hs, HeapObjectDesc *obj)
1236 {
1237 uintptr_t i;
1238 if (hs->objects_count * 2 >= hs->objects_hash_size) {
1239 HeapObjectDesc **n;
1240 uintptr_t old_size = hs->objects_hash_size;
1241 hs->objects_hash_size *= 2;
1242 if (hs->objects_hash_size == 0)
1243 hs->objects_hash_size = 4;
1244 n = calloc (sizeof (void*) * hs->objects_hash_size, 1);
1245 for (i = 0; i < old_size; ++i) {
1246 if (hs->objects_hash [i])
1247 add_heap_hashed_obj (n, hs->objects_hash_size, hs->objects_hash [i]);
1248 }
1249 if (hs->objects_hash)
1250 free (hs->objects_hash);
1251 hs->objects_hash = n;
1252 }
1253 hs->objects_count += add_heap_hashed_obj (hs->objects_hash, hs->objects_hash_size, obj);
1254 }
1255
1256 static void
1257 heap_shot_resolve_reverse_refs (HeapShot *hs)
1258 {
1259 uintptr_t i;
1260 for (i = 0; i < hs->objects_hash_size; ++i) {
1261 uintptr_t r;
1262 HeapObjectDesc *ho = hs->objects_hash [i];
1263 if (!ho)
1264 continue;
1265 for (r = 0; r < ho->num_refs; ++r) {
1266 uintptr_t oi = heap_shot_find_obj_slot (hs, ho->refs [r]);
1267 add_heap_class_rev (ho->hklass, hs->objects_hash [oi]->hklass);
1268 }
1269 }
1270 }
1271
1272 #define MARK_GRAY 1
1273 #define MARK_BLACK 2
1274
1275 static void
1276 heap_shot_mark_objects (HeapShot *hs)
1277 {
1278 uintptr_t i, oi, r;
1279 unsigned char *marks;
1280 HeapObjectDesc *obj, *ref;
1281 int marked_some;
1282 uintptr_t num_marked = 0, num_unmarked;
1283 for (i = 0; i < hs->num_roots; ++i) {
1284 HeapClassDesc *cd;
1285 oi = heap_shot_find_obj_slot (hs, hs->roots [i]);
1286 if (oi == -1) {
1287 continue;
1288 }
1289 obj = hs->objects_hash [oi];
1290 cd = obj->hklass;
1291 if (hs->roots_types [i] & MONO_PROFILE_GC_ROOT_PINNING)
1292 cd->pinned_references++;
1293 cd->root_references++;
1294 }
1295 if (!debug)
1296 return;
1297 /* consistency checks: it seems not all the objects are walked in the heap in some cases */
1298 marks = calloc (hs->objects_hash_size, 1);
1299 if (!marks)
1300 return;
1301 for (i = 0; i < hs->num_roots; ++i) {
1302 oi = heap_shot_find_obj_slot (hs, hs->roots [i]);
1303 if (oi == -1) {
1304 fprintf (outfile, "root type 0x%x for obj %p (%s) not found in heap\n", hs->roots_types [i], (void*)hs->roots [i], lookup_class (hs->roots_extra [i])->name);
1305 continue;
1306 }
1307 obj = hs->objects_hash [oi];
1308 if (!marks [oi]) {
1309 marks [oi] = obj->num_refs? MARK_GRAY: MARK_BLACK;
1310 num_marked++;
1311 }
1312 }
1313 marked_some = 1;
1314 while (marked_some) {
1315 marked_some = 0;
1316 for (i = 0; i < hs->objects_hash_size; ++i) {
1317 if (marks [i] != MARK_GRAY)
1318 continue;
1319 marks [i] = MARK_BLACK;
1320 obj = hs->objects_hash [i];
1321 for (r = 0; r < obj->num_refs; ++r) {
1322 oi = heap_shot_find_obj_slot (hs, obj->refs [r]);
1323 if (oi == -1) {
1324 fprintf (outfile, "referenced obj %p not found in heap\n", (void*)obj->refs [r]);
1325 continue;
1326 }
1327 ref = hs->objects_hash [oi];
1328 if (!marks [oi]) {
1329 marks [oi] = ref->num_refs? MARK_GRAY: MARK_BLACK;
1330 }
1331 }
1332 marked_some++;
1333 }
1334 }
1335
1336 num_unmarked = 0;
1337 for (i = 0; i < hs->objects_hash_size; ++i) {
1338 if (hs->objects_hash [i] && !marks [i]) {
1339 num_unmarked++;
1340 fprintf (outfile, "object %p (%s) unmarked\n", (void*)hs->objects_hash [i], hs->objects_hash [i]->hklass->klass->name);
1341 }
1342 }
1343 fprintf (outfile, "Total unmarked: %zd/%zd\n", num_unmarked, hs->objects_count);
1344 free (marks);
1345 }
1346
1347 static void
1348 heap_shot_free_objects (HeapShot *hs)
1349 {
1350 uintptr_t i;
1351 for (i = 0; i < hs->objects_hash_size; ++i) {
1352 HeapObjectDesc *ho = hs->objects_hash [i];
1353 if (ho)
1354 free (ho);
1355 }
1356 if (hs->objects_hash)
1357 free (hs->objects_hash);
1358 hs->objects_hash = NULL;
1359 hs->objects_hash_size = 0;
1360 hs->objects_count = 0;
1361 }
1362
1363
1364 struct _BackTrace {
1365 BackTrace *next;
1366 unsigned int hash;
1367 int count;
1368 int id;
1369 MethodDesc *methods [1];
1370 };
1371
1372 static BackTrace *backtrace_hash [HASH_SIZE];
1373 static BackTrace **backtraces = NULL;
1374 static int num_backtraces = 0;
1375 static int next_backtrace = 0;
1376
1377 static int
1378 hash_backtrace (int count, MethodDesc **methods)
1379 {
1380 int hash = count;
1381 int i;
1382 for (i = 0; i < count; ++i) {
1383 hash = (hash << 5) - hash + methods [i]->method;
1384 }
1385 return hash;
1386 }
1387
1388 static int
1389 compare_backtrace (BackTrace *bt, int count, MethodDesc **methods)
1390 {
1391 int i;
1392 if (bt->count != count)
1393 return 0;
1394 for (i = 0; i < count; ++i)
1395 if (methods [i] != bt->methods [i])
1396 return 0;
1397 return 1;
1398 }
1399
1400 static BackTrace*
1401 add_backtrace (int count, MethodDesc **methods)
1402 {
1403 int hash = hash_backtrace (count, methods);
1404 int slot = (hash & 0xffff) % HASH_SIZE;
1405 BackTrace *bt = backtrace_hash [slot];
1406 while (bt) {
1407 if (bt->hash == hash && compare_backtrace (bt, count, methods))
1408 return bt;
1409 bt = bt->next;
1410 }
1411 bt = malloc (sizeof (BackTrace) + ((count - 1) * sizeof (void*)));
1412 bt->next = backtrace_hash [slot];
1413 backtrace_hash [slot] = bt;
1414 if (next_backtrace == num_backtraces) {
1415 num_backtraces *= 2;
1416 if (!num_backtraces)
1417 num_backtraces = 16;
1418 backtraces = realloc (backtraces, sizeof (void*) * num_backtraces);
1419 }
1420 bt->id = next_backtrace++;
1421 backtraces [bt->id] = bt;
1422 bt->count = count;
1423 bt->hash = hash;
1424 for (slot = 0; slot < count; ++slot)
1425 bt->methods [slot] = methods [slot];
1426
1427 return bt;
1428 }
1429
1430 typedef struct _MonitorDesc MonitorDesc;
1431 typedef struct _ThreadContext ThreadContext;
1432
1433 typedef struct {
1434 FILE *file;
1435 #if defined (HAVE_SYS_ZLIB)
1436 gzFile gzfile;
1437 #endif
1438 unsigned char *buf;
1439 int size;
1440 int data_version;
1441 int version_major;
1442 int version_minor;
1443 int timer_overhead;
1444 int pid;
1445 int port;
1446 uint64_t startup_time;
1447 ThreadContext *threads;
1448 ThreadContext *current;
1449 } ProfContext;
1450
1451 struct _ThreadContext {
1452 ThreadContext *next;
1453 intptr_t thread_id;
1454 char *name;
1455 /* emulated stack */
1456 MethodDesc **stack;
1457 uint64_t *time_stack;
1458 uint64_t *callee_time_stack;
1459 uint64_t last_time;
1460 uint64_t contention_start;
1461 MonitorDesc *monitor;
1462 int stack_size;
1463 int stack_id;
1464 HeapShot *current_heap_shot;
1465 uintptr_t num_roots;
1466 uintptr_t size_roots;
1467 uintptr_t *roots;
1468 uintptr_t *roots_extra;
1469 int *roots_types;
1470 uint64_t gc_start_times [3];
1471 };
1472
1473 static void
1474 ensure_buffer (ProfContext *ctx, int size)
1475 {
1476 if (ctx->size < size) {
1477 ctx->buf = realloc (ctx->buf, size);
1478 ctx->size = size;
1479 }
1480 }
1481
1482 static int
1483 load_data (ProfContext *ctx, int size)
1484 {
1485 ensure_buffer (ctx, size);
1486 #if defined (HAVE_SYS_ZLIB)
1487 if (ctx->gzfile) {
1488 int r = gzread (ctx->gzfile, ctx->buf, size);
1489 if (r == 0)
1490 return size == 0? 1: 0;
1491 return r == size;
1492 } else
1493 #endif
1494 {
1495 int r = fread (ctx->buf, size, 1, ctx->file);
1496 if (r == 0)
1497 return size == 0? 1: 0;
1498 return r;
1499 }
1500 }
1501
1502 static ThreadContext*
1503 get_thread (ProfContext *ctx, intptr_t thread_id)
1504 {
1505 ThreadContext *thread;
1506 if (ctx->current && ctx->current->thread_id == thread_id)
1507 return ctx->current;
1508 thread = ctx->threads;
1509 while (thread) {
1510 if (thread->thread_id == thread_id) {
1511 return thread;
1512 }
1513 thread = thread->next;
1514 }
1515 thread = calloc (sizeof (ThreadContext), 1);
1516 thread->next = ctx->threads;
1517 ctx->threads = thread;
1518 thread->thread_id = thread_id;
1519 thread->last_time = 0;
1520 thread->stack_id = 0;
1521 thread->stack_size = 32;
1522 thread->stack = malloc (thread->stack_size * sizeof (void*));
1523 thread->time_stack = malloc (thread->stack_size * sizeof (uint64_t));
1524 thread->callee_time_stack = malloc (thread->stack_size * sizeof (uint64_t));
1525 return thread;
1526 }
1527
1528 static ThreadContext*
1529 load_thread (ProfContext *ctx, intptr_t thread_id)
1530 {
1531 ThreadContext *thread = get_thread (ctx, thread_id);
1532 ctx->current = thread;
1533 return thread;
1534 }
1535
1536 static void
1537 ensure_thread_stack (ThreadContext *thread)
1538 {
1539 if (thread->stack_id == thread->stack_size) {
1540 thread->stack_size *= 2;
1541 thread->stack = realloc (thread->stack, thread->stack_size * sizeof (void*));
1542 thread->time_stack = realloc (thread->time_stack, thread->stack_size * sizeof (uint64_t));
1543 thread->callee_time_stack = realloc (thread->callee_time_stack, thread->stack_size * sizeof (uint64_t));
1544 }
1545 }
1546
1547 static int
1548 add_trace_hashed (CallContext *traces, int size, BackTrace *bt, uint64_t value)
1549 {
1550 int i;
1551 unsigned int start_pos;
1552 start_pos = bt->hash % size;
1553 i = start_pos;
1554 do {
1555 if (traces [i].bt == bt) {
1556 traces [i].count += value;
1557 return 0;
1558 } else if (!traces [i].bt) {
1559 traces [i].bt = bt;
1560 traces [i].count += value;
1561 return 1;
1562 }
1563 /* wrap around */
1564 if (++i == size)
1565 i = 0;
1566 } while (i != start_pos);
1567 /* should not happen */
1568 printf ("failed trace store\n");
1569 return 0;
1570 }
1571
1572 static void
1573 add_trace_bt (BackTrace *bt, TraceDesc *trace, uint64_t value)
1574 {
1575 int i;
1576 if (!collect_traces)
1577 return;
1578 if (trace->count * 2 >= trace->size) {
1579 CallContext *n;
1580 int old_size = trace->size;
1581 trace->size *= 2;
1582 if (trace->size == 0)
1583 trace->size = 4;
1584 n = calloc (sizeof (CallContext) * trace->size, 1);
1585 for (i = 0; i < old_size; ++i) {
1586 if (trace->traces [i].bt)
1587 add_trace_hashed (n, trace->size, trace->traces [i].bt, trace->traces [i].count);
1588 }
1589 if (trace->traces)
1590 free (trace->traces);
1591 trace->traces = n;
1592 }
1593 trace->count += add_trace_hashed (trace->traces, trace->size, bt, value);
1594 }
1595
1596 static BackTrace*
1597 add_trace_thread (ThreadContext *thread, TraceDesc *trace, uint64_t value)
1598 {
1599 BackTrace *bt;
1600 int count = thread->stack_id;
1601 if (!collect_traces)
1602 return NULL;
1603 if (count > trace_max)
1604 count = trace_max;
1605 bt = add_backtrace (count, thread->stack + thread->stack_id - count);
1606 add_trace_bt (bt, trace, value);
1607 return bt;
1608 }
1609
1610 static BackTrace*
1611 add_trace_methods (MethodDesc **methods, int count, TraceDesc *trace, uint64_t value)
1612 {
1613 BackTrace *bt;
1614 if (!collect_traces)
1615 return NULL;
1616 if (count > trace_max)
1617 count = trace_max;
1618 bt = add_backtrace (count, methods);
1619 add_trace_bt (bt, trace, value);
1620 return bt;
1621 }
1622
1623 static void
1624 thread_add_root (ThreadContext *ctx, uintptr_t obj, int root_type, uintptr_t extra_info)
1625 {
1626 if (ctx->num_roots == ctx->size_roots) {
1627 int new_size = ctx->size_roots * 2;
1628 if (!new_size)
1629 new_size = 4;
1630 ctx->roots = realloc (ctx->roots, new_size * sizeof (uintptr_t));
1631 ctx->roots_extra = realloc (ctx->roots_extra, new_size * sizeof (uintptr_t));
1632 ctx->roots_types = realloc (ctx->roots_types, new_size * sizeof (int));
1633 ctx->size_roots = new_size;
1634 }
1635 ctx->roots_types [ctx->num_roots] = root_type;
1636 ctx->roots_extra [ctx->num_roots] = extra_info;
1637 ctx->roots [ctx->num_roots++] = obj;
1638 }
1639
1640 static int
1641 compare_callc (const void *a, const void *b)
1642 {
1643 const CallContext *A = a;
1644 const CallContext *B = b;
1645 if (B->count == A->count)
1646 return 0;
1647 if (B->count < A->count)
1648 return -1;
1649 return 1;
1650 }
1651
1652 static void
1653 sort_context_array (TraceDesc* traces)
1654 {
1655 int i, j;
1656 for (i = 0, j = 0; i < traces->size; ++i) {
1657 if (traces->traces [i].bt) {
1658 traces->traces [j].bt = traces->traces [i].bt;
1659 traces->traces [j].count = traces->traces [i].count;
1660 j++;
1661 }
1662 }
1663 qsort (traces->traces, traces->count, sizeof (CallContext), compare_callc);
1664 }
1665
1666 static void
1667 push_method (ThreadContext *thread, MethodDesc *method, uint64_t timestamp)
1668 {
1669 ensure_thread_stack (thread);
1670 thread->time_stack [thread->stack_id] = timestamp;
1671 thread->callee_time_stack [thread->stack_id] = 0;
1672 thread->stack [thread->stack_id++] = method;
1673 method->recurse_count++;
1674 }
1675
1676 static void
1677 pop_method (ThreadContext *thread, MethodDesc *method, uint64_t timestamp)
1678 {
1679 method->recurse_count--;
1680 if (thread->stack_id > 0 && thread->stack [thread->stack_id - 1] == method) {
1681 uint64_t tdiff;
1682 thread->stack_id--;
1683 method->calls++;
1684 if (timestamp < thread->time_stack [thread->stack_id])
1685 fprintf (outfile, "time went backwards for %s\n", method->name);
1686 tdiff = timestamp - thread->time_stack [thread->stack_id];
1687 if (thread->callee_time_stack [thread->stack_id] > tdiff)
1688 fprintf (outfile, "callee time bigger for %s\n", method->name);
1689 method->self_time += tdiff - thread->callee_time_stack [thread->stack_id];
1690 method->callee_time += thread->callee_time_stack [thread->stack_id];
1691 if (thread->stack_id)
1692 thread->callee_time_stack [thread->stack_id - 1] += tdiff;
1693 //fprintf (outfile, "method %s took %d\n", method->name, (int)(tdiff/1000));
1694 } else {
1695 fprintf (outfile, "unmatched leave at stack pos: %d for method %s\n", thread->stack_id, method->name);
1696 }
1697 }
1698
1699 typedef struct {
1700 uint64_t total_time;
1701 uint64_t max_time;
1702 int count;
1703 } GCDesc;
1704 static GCDesc gc_info [3];
1705 static uint64_t max_heap_size;
1706 static uint64_t gc_object_moves;
1707 static int gc_resizes;
1708 typedef struct {
1709 uint64_t created;
1710 uint64_t destroyed;
1711 uint64_t live;
1712 uint64_t max_live;
1713 TraceDesc traces;
1714 } HandleInfo;
1715 static HandleInfo handle_info [4];
1716
1717 static const char*
1718 gc_event_name (int ev)
1719 {
1720 switch (ev) {
1721 case MONO_GC_EVENT_START: return "start";
1722 case MONO_GC_EVENT_MARK_START: return "mark start";
1723 case MONO_GC_EVENT_MARK_END: return "mark end";
1724 case MONO_GC_EVENT_RECLAIM_START: return "reclaim start";
1725 case MONO_GC_EVENT_RECLAIM_END: return "reclaim end";
1726 case MONO_GC_EVENT_END: return "end";
1727 case MONO_GC_EVENT_PRE_STOP_WORLD: return "pre stop";
1728 case MONO_GC_EVENT_POST_STOP_WORLD: return "post stop";
1729 case MONO_GC_EVENT_PRE_START_WORLD: return "pre start";
1730 case MONO_GC_EVENT_POST_START_WORLD: return "post start";
1731 default:
1732 return "unknown";
1733 }
1734 }
1735
1736 static uint64_t clause_summary [MONO_EXCEPTION_CLAUSE_FAULT + 1];
1737 static uint64_t throw_count = 0;
1738 static TraceDesc exc_traces;
1739
1740 static const char*
1741 clause_name (int type)
1742 {
1743 switch (type) {
1744 case MONO_EXCEPTION_CLAUSE_NONE: return "catch";
1745 case MONO_EXCEPTION_CLAUSE_FILTER: return "filter";
1746 case MONO_EXCEPTION_CLAUSE_FINALLY: return "finally";
1747 case MONO_EXCEPTION_CLAUSE_FAULT: return "fault";
1748 default: return "invalid";
1749 }
1750 }
1751
1752 static uint64_t monitor_contention;
1753 static uint64_t monitor_failed;
1754 static uint64_t monitor_acquired;
1755
1756 struct _MonitorDesc {
1757 MonitorDesc *next;
1758 uintptr_t objid;
1759 uintptr_t contentions;
1760 uint64_t wait_time;
1761 uint64_t max_wait_time;
1762 TraceDesc traces;
1763 };
1764
1765 static MonitorDesc* monitor_hash [SMALL_HASH_SIZE] = {0};
1766 static int num_monitors = 0;
1767
1768 static MonitorDesc*
1769 lookup_monitor (uintptr_t objid)
1770 {
1771 int slot = ((objid >> 3) & 0xffff) % SMALL_HASH_SIZE;
1772 MonitorDesc *cd = monitor_hash [slot];
1773 while (cd && cd->objid != objid)
1774 cd = cd->next;
1775 if (!cd) {
1776 cd = calloc (sizeof (MonitorDesc), 1);
1777 cd->objid = objid;
1778 cd->next = monitor_hash [slot];
1779 monitor_hash [slot] = cd;
1780 num_monitors++;
1781 }
1782 return cd;
1783 }
1784
1785 static const char*
1786 monitor_ev_name (int ev)
1787 {
1788 switch (ev) {
1789 case MONO_PROFILER_MONITOR_CONTENTION: return "contended";
1790 case MONO_PROFILER_MONITOR_DONE: return "acquired";
1791 case MONO_PROFILER_MONITOR_FAIL: return "not taken";
1792 default: return "invalid";
1793 }
1794 }
1795
1796 static const char*
1797 get_handle_name (int htype)
1798 {
1799 switch (htype) {
1800 case 0: return "weak";
1801 case 1: return "weaktrack";
1802 case 2: return "normal";
1803 case 3: return "pinned";
1804 default: return "unknown";
1805 }
1806 }
1807
1808 static const char*
1809 get_root_name (int rtype)
1810 {
1811 switch (rtype & MONO_PROFILE_GC_ROOT_TYPEMASK) {
1812 case MONO_PROFILE_GC_ROOT_STACK: return "stack";
1813 case MONO_PROFILE_GC_ROOT_FINALIZER: return "finalizer";
1814 case MONO_PROFILE_GC_ROOT_HANDLE: return "handle";
1815 case MONO_PROFILE_GC_ROOT_OTHER: return "other";
1816 case MONO_PROFILE_GC_ROOT_MISC: return "misc";
1817 default: return "unknown";
1818 }
1819 }
1820
1821 static MethodDesc**
1822 decode_bt (MethodDesc** sframes, int *size, unsigned char *p, unsigned char **endp, intptr_t ptr_base)
1823 {
1824 MethodDesc **frames;
1825 int i;
1826 int flags = decode_uleb128 (p, &p);
1827 int count = decode_uleb128 (p, &p);
1828 if (flags != 0)
1829 return NULL;
1830 if (count > *size)
1831 frames = malloc (count * sizeof (void*));
1832 else
1833 frames = sframes;
1834 for (i = 0; i < count; ++i) {
1835 intptr_t ptrdiff = decode_sleb128 (p, &p);
1836 frames [i] = lookup_method (ptr_base + ptrdiff);
1837 }
1838 *size = count;
1839 *endp = p;
1840 return frames;
1841 }
1842
1843 static void
1844 tracked_creation (uintptr_t obj, ClassDesc *cd, uint64_t size, BackTrace *bt, uint64_t timestamp)
1845 {
1846 int i;
1847 for (i = 0; i < num_tracked_objects; ++i) {
1848 if (tracked_objects [i] != obj)
1849 continue;
1850 fprintf (outfile, "Object %p created (%s, %llu bytes) at %.3f secs.\n", (void*)obj, cd->name, (unsigned long long) size, (timestamp - startup_time)/1000000000.0);
1851 if (bt && bt->count) {
1852 int k;
1853 for (k = 0; k < bt->count; ++k)
1854 fprintf (outfile, "\t%s\n", bt->methods [k]->name);
1855 }
1856 }
1857 }
1858
1859 static void
1860 track_handle (uintptr_t obj, int htype, uint32_t handle)
1861 {
1862 int i;
1863 for (i = 0; i < num_tracked_objects; ++i) {
1864 if (tracked_objects [i] == obj)
1865 fprintf (outfile, "Object %p referenced from handle %u\n", (void*)obj, handle);
1866 }
1867 }
1868
1869 static void
1870 track_move (uintptr_t src, uintptr_t dst)
1871 {
1872 int i;
1873 for (i = 0; i < num_tracked_objects; ++i) {
1874 if (tracked_objects [i] == src)
1875 fprintf (outfile, "Object %p moved to %p\n", (void*)src, (void*)dst);
1876 else if (tracked_objects [i] == dst)
1877 fprintf (outfile, "Object %p moved from %p\n", (void*)dst, (void*)src);
1878 }
1879 }
1880
1881 static void
1882 track_obj_reference (uintptr_t obj, uintptr_t parent, ClassDesc *cd)
1883 {
1884 int i;
1885 for (i = 0; i < num_tracked_objects; ++i) {
1886 if (tracked_objects [i] == obj)
1887 fprintf (outfile, "Object %p referenced from %p (%s).\n", (void*)obj, (void*)parent, cd->name);
1888 }
1889 }
1890
1891 static void
1892 found_object (uintptr_t obj)
1893 {
1894 num_tracked_objects ++;
1895 tracked_objects = realloc (tracked_objects, num_tracked_objects * sizeof (tracked_objects [0]));
1896 tracked_objects [num_tracked_objects - 1] = obj;
1897 }
1898
1899 #define OBJ_ADDR(diff) ((obj_base + diff) << 3)
1900 #define LOG_TIME(base,diff) /*fprintf("outfile, time %llu + %llu near offset %d\n", base, diff, p - ctx->buf)*/
1901
1902 static int
1903 decode_buffer (ProfContext *ctx)
1904 {
1905 unsigned char *p;
1906 unsigned char *end;
1907 intptr_t thread_id;
1908 intptr_t ptr_base;
1909 intptr_t obj_base;
1910 intptr_t method_base;
1911 uint64_t time_base;
1912 uint64_t file_offset;
1913 int len, i;
1914 ThreadContext *thread;
1915
1916 #ifdef HAVE_SYS_ZLIB
1917 if (ctx->gzfile)
1918 file_offset = gztell (ctx->gzfile);
1919 else
1920 #endif
1921 file_offset = ftell (ctx->file);
1922 if (!load_data (ctx, 48))
1923 return 0;
1924 p = ctx->buf;
1925 if (read_int32 (p) != BUF_ID) {
1926 fprintf (outfile, "Incorrect buffer id: 0x%x\n", read_int32 (p));
1927 for (i = 0; i < 48; ++i) {
1928 fprintf (outfile, "0x%x%s", p [i], i % 8?" ":"\n");
1929 }
1930 return 0;
1931 }
1932 len = read_int32 (p + 4);
1933 time_base = read_int64 (p + 8);
1934 ptr_base = read_int64 (p + 16);
1935 obj_base = read_int64 (p + 24);
1936 thread_id = read_int64 (p + 32);
1937 method_base = read_int64 (p + 40);
1938 if (debug)
1939 fprintf (outfile, "buf: thread:%zx, len: %d, time: %llu, file offset: %llu\n", thread_id, len, (unsigned long long) time_base, (unsigned long long) file_offset);
1940 thread = load_thread (ctx, thread_id);
1941 if (!load_data (ctx, len))
1942 return 0;
1943 if (!startup_time) {
1944 startup_time = time_base;
1945 if (use_time_filter) {
1946 time_from += startup_time;
1947 time_to += startup_time;
1948 }
1949 if (!thread->name)
1950 thread->name = pstrdup ("Main");
1951 }
1952 for (i = 0; i < thread->stack_id; ++i)
1953 thread->stack [i]->recurse_count++;
1954 p = ctx->buf;
1955 end = p + len;
1956 while (p < end) {
1957 switch (*p & 0xf) {
1958 case TYPE_GC: {
1959 int subtype = *p & 0xf0;
1960 uint64_t tdiff = decode_uleb128 (p + 1, &p);
1961 LOG_TIME (time_base, tdiff);
1962 time_base += tdiff;
1963 if (subtype == TYPE_GC_RESIZE) {
1964 uint64_t new_size = decode_uleb128 (p, &p);
1965 if (debug)
1966 fprintf (outfile, "gc heap resized to %llu\n", (unsigned long long) new_size);
1967 gc_resizes++;
1968 if (new_size > max_heap_size)
1969 max_heap_size = new_size;
1970 } else if (subtype == TYPE_GC_EVENT) {
1971 uint64_t ev = decode_uleb128 (p, &p);
1972 int gen = decode_uleb128 (p, &p);
1973 if (debug)
1974 fprintf (outfile, "gc event for gen%d: %s at %llu (thread: 0x%zx)\n", gen, gc_event_name (ev), (unsigned long long) time_base, thread->thread_id);
1975 if (gen > 2) {
1976 fprintf (outfile, "incorrect gc gen: %d\n", gen);
1977 break;
1978 }
1979 if (ev == MONO_GC_EVENT_START) {
1980 thread->gc_start_times [gen] = time_base;
1981 gc_info [gen].count++;
1982 } else if (ev == MONO_GC_EVENT_END) {
1983 tdiff = time_base - thread->gc_start_times [gen];
1984 gc_info [gen].total_time += tdiff;
1985 if (tdiff > gc_info [gen].max_time)
1986 gc_info [gen].max_time = tdiff;
1987 }
1988 } else if (subtype == TYPE_GC_MOVE) {
1989 int j, num = decode_uleb128 (p, &p);
1990 gc_object_moves += num / 2;
1991 for (j = 0; j < num; j += 2) {
1992 intptr_t obj1diff = decode_sleb128 (p, &p);
1993 intptr_t obj2diff = decode_sleb128 (p, &p);
1994 if (num_tracked_objects)
1995 track_move (OBJ_ADDR (obj1diff), OBJ_ADDR (obj2diff));
1996 if (debug) {
1997 fprintf (outfile, "moved obj %p to %p\n", (void*)OBJ_ADDR (obj1diff), (void*)OBJ_ADDR (obj2diff));
1998 }
1999 }
2000 } else if (subtype == TYPE_GC_HANDLE_CREATED) {
2001 int htype = decode_uleb128 (p, &p);
2002 uint32_t handle = decode_uleb128 (p, &p);
2003 intptr_t objdiff = decode_sleb128 (p, &p);
2004 if (htype > 3)
2005 return 0;
2006 handle_info [htype].created++;
2007 handle_info [htype].live++;
2008 add_trace_thread (thread, &handle_info [htype].traces, 1);
2009 /* FIXME: we don't take into account timing here */
2010 if (handle_info [htype].live > handle_info [htype].max_live)
2011 handle_info [htype].max_live = handle_info [htype].live;
2012 if (num_tracked_objects)
2013 track_handle (OBJ_ADDR (objdiff), htype, handle);
2014 if (debug)
2015 fprintf (outfile, "handle (%s) %u created for object %p\n", get_handle_name (htype), handle, (void*)OBJ_ADDR (objdiff));
2016 } else if (subtype == TYPE_GC_HANDLE_DESTROYED) {
2017 int htype = decode_uleb128 (p, &p);
2018 uint32_t handle = decode_uleb128 (p, &p);
2019 if (htype > 3)
2020 return 0;
2021 handle_info [htype].destroyed ++;
2022 handle_info [htype].live--;
2023 if (debug)
2024 fprintf (outfile, "handle (%s) %u destroyed\n", get_handle_name (htype), handle);
2025 }
2026 break;
2027 }
2028 case TYPE_METADATA: {
2029 int error = *p & TYPE_LOAD_ERR;
2030 uint64_t tdiff = decode_uleb128 (p + 1, &p);
2031 int mtype = *p++;
2032 intptr_t ptrdiff = decode_sleb128 (p, &p);
2033 LOG_TIME (time_base, tdiff);
2034 time_base += tdiff;
2035 if (mtype == TYPE_CLASS) {
2036 intptr_t imptrdiff = decode_sleb128 (p, &p);
2037 uint64_t flags = decode_uleb128 (p, &p);
2038 if (flags) {
2039 fprintf (outfile, "non-zero flags in class\n");
2040 return 0;
2041 }
2042 if (debug)
2043 fprintf (outfile, "loaded class %p (%s in %p) at %llu\n", (void*)(ptr_base + ptrdiff), p, (void*)(ptr_base + imptrdiff), (unsigned long long) time_base);
2044 if (!error)
2045 add_class (ptr_base + ptrdiff, (char*)p);
2046 while (*p) p++;
2047 p++;
2048 } else if (mtype == TYPE_IMAGE) {
2049 uint64_t flags = decode_uleb128 (p, &p);
2050 if (flags) {
2051 fprintf (outfile, "non-zero flags in image\n");
2052 return 0;
2053 }
2054 if (debug)
2055 fprintf (outfile, "loaded image %p (%s) at %llu\n", (void*)(ptr_base + ptrdiff), p, (unsigned long long) time_base);
2056 if (!error)
2057 add_image (ptr_base + ptrdiff, (char*)p);
2058 while (*p) p++;
2059 p++;
2060 } else if (mtype == TYPE_THREAD) {
2061 ThreadContext *nt;
2062 uint64_t flags = decode_uleb128 (p, &p);
2063 if (flags) {
2064 fprintf (outfile, "non-zero flags in thread\n");
2065 return 0;
2066 }
2067 nt = get_thread (ctx, ptr_base + ptrdiff);
2068 nt->name = pstrdup ((char*)p);
2069 if (debug)
2070 fprintf (outfile, "thread %p named: %s\n", (void*)(ptr_base + ptrdiff), p);
2071 while (*p) p++;
2072 p++;
2073 }
2074 break;
2075 }
2076 case TYPE_ALLOC: {
2077 int has_bt = *p & TYPE_ALLOC_BT;
2078 uint64_t tdiff = decode_uleb128 (p + 1, &p);
2079 intptr_t ptrdiff = decode_sleb128 (p, &p);
2080 intptr_t objdiff = decode_sleb128 (p, &p);
2081 uint64_t len;
2082 int num_bt = 0;
2083 MethodDesc* sframes [8];
2084 MethodDesc** frames = sframes;
2085 ClassDesc *cd = lookup_class (ptr_base + ptrdiff);
2086 len = decode_uleb128 (p, &p);
2087 LOG_TIME (time_base, tdiff);
2088 time_base += tdiff;
2089 if (debug)
2090 fprintf (outfile, "alloced object %p, size %llu (%s) at %llu\n", (void*)OBJ_ADDR (objdiff), (unsigned long long) len, lookup_class (ptr_base + ptrdiff)->name, (unsigned long long) time_base);
2091 if (has_bt) {
2092 num_bt = 8;
2093 frames = decode_bt (sframes, &num_bt, p, &p, ptr_base);
2094 if (!frames) {
2095 fprintf (outfile, "Cannot load backtrace\n");
2096 return 0;
2097 }
2098 }
2099 if ((thread_filter && thread_filter == thread->thread_id) || (time_base >= time_from && time_base < time_to)) {
2100 BackTrace *bt;
2101 cd->allocs++;
2102 cd->alloc_size += len;
2103 if (has_bt)
2104 bt = add_trace_methods (frames, num_bt, &cd->traces, len);
2105 else
2106 bt = add_trace_thread (thread, &cd->traces, len);
2107 if (find_size && len >= find_size) {
2108 if (!find_name || strstr (cd->name, find_name))
2109 found_object (OBJ_ADDR (objdiff));
2110 } else if (!find_size && find_name && strstr (cd->name, find_name)) {
2111 found_object (OBJ_ADDR (objdiff));
2112 }
2113 if (num_tracked_objects)
2114 tracked_creation (OBJ_ADDR (objdiff), cd, len, bt, time_base);
2115 }
2116 if (frames != sframes)
2117 free (frames);
2118 break;
2119 }
2120 case TYPE_METHOD: {
2121 int subtype = *p & 0xf0;
2122 uint64_t tdiff = decode_uleb128 (p + 1, &p);
2123 int64_t ptrdiff = decode_sleb128 (p, &p);
2124 LOG_TIME (time_base, tdiff);
2125 time_base += tdiff;
2126 method_base += ptrdiff;
2127 if (subtype == TYPE_JIT) {
2128 intptr_t codediff = decode_sleb128 (p, &p);
2129 int codelen = decode_uleb128 (p, &p);
2130 MethodDesc *jitted_method;
2131 if (debug)
2132 fprintf (outfile, "jitted method %p (%s), size: %d, code: %p\n", (void*)(method_base), p, codelen, (void*)(ptr_base + codediff));
2133 jitted_method = add_method (method_base, (char*)p, ptr_base + codediff, codelen);
2134 if (!(time_base >= time_from && time_base < time_to))
2135 jitted_method->ignore_jit = 1;
2136 while (*p) p++;
2137 p++;
2138 } else {
2139 MethodDesc *method;
2140 if ((thread_filter && thread_filter != thread->thread_id))
2141 break;
2142 if (!(time_base >= time_from && time_base < time_to))
2143 break;
2144 method = lookup_method (method_base);
2145 if (subtype == TYPE_ENTER) {
2146 add_trace_thread (thread, &method->traces, 1);
2147 push_method (thread, method, time_base);
2148 } else {
2149 pop_method (thread, method, time_base);
2150 }
2151 if (debug)
2152 fprintf (outfile, "%s method %s\n", subtype == TYPE_ENTER? "enter": subtype == TYPE_EXC_LEAVE? "exleave": "leave", method->name);
2153 }
2154 break;
2155 }
2156 case TYPE_HEAP: {
2157 int subtype = *p & 0xf0;
2158 if (subtype == TYPE_HEAP_OBJECT) {
2159 HeapObjectDesc *ho = NULL;
2160 int i;
2161 intptr_t objdiff = decode_sleb128 (p + 1, &p);
2162 intptr_t ptrdiff = decode_sleb128 (p, &p);
2163 uint64_t size = decode_uleb128 (p, &p);
2164 uintptr_t num = decode_uleb128 (p, &p);
2165 uintptr_t ref_offset = 0;
2166 uintptr_t last_obj_offset = 0;
2167 ClassDesc *cd = lookup_class (ptr_base + ptrdiff);
2168 if (size) {
2169 HeapClassDesc *hcd = add_heap_shot_class (thread->current_heap_shot, cd, size);
2170 if (collect_traces) {
2171 ho = alloc_heap_obj (OBJ_ADDR (objdiff), hcd, num);
2172 add_heap_shot_obj (thread->current_heap_shot, ho);
2173 ref_offset = 0;
2174 }
2175 } else {
2176 if (collect_traces)
2177 ho = heap_shot_obj_add_refs (thread->current_heap_shot, OBJ_ADDR (objdiff), num, &ref_offset);
2178 }
2179 for (i = 0; i < num; ++i) {
2180 /* FIXME: use object distance to measure how good
2181 * the GC is at keeping related objects close
2182 */
2183 uintptr_t offset = ctx->data_version > 1? last_obj_offset + decode_uleb128 (p, &p): -1;
2184 intptr_t obj1diff = decode_sleb128 (p, &p);
2185 last_obj_offset = offset;
2186 if (collect_traces)
2187 ho->refs [ref_offset + i] = OBJ_ADDR (obj1diff);
2188 if (num_tracked_objects)
2189 track_obj_reference (OBJ_ADDR (obj1diff), OBJ_ADDR (objdiff), cd);
2190 }
2191 if (debug && size)
2192 fprintf (outfile, "traced object %p, size %llu (%s), refs: %zd\n", (void*)OBJ_ADDR (objdiff), (unsigned long long) size, cd->name, num);
2193 } else if (subtype == TYPE_HEAP_ROOT) {
2194 uintptr_t num = decode_uleb128 (p + 1, &p);
2195 uintptr_t gc_num G_GNUC_UNUSED = decode_uleb128 (p, &p);
2196 int i;
2197 for (i = 0; i < num; ++i) {
2198 intptr_t objdiff = decode_sleb128 (p, &p);
2199 int root_type = decode_uleb128 (p, &p);
2200 /* we just discard the extra info for now */
2201 uintptr_t extra_info = decode_uleb128 (p, &p);
2202 if (debug)
2203 fprintf (outfile, "object %p is a %s root\n", (void*)OBJ_ADDR (objdiff), get_root_name (root_type));
2204 if (collect_traces)
2205 thread_add_root (thread, OBJ_ADDR (objdiff), root_type, extra_info);
2206 }
2207 } else if (subtype == TYPE_HEAP_END) {
2208 uint64_t tdiff = decode_uleb128 (p + 1, &p);
2209 LOG_TIME (time_base, tdiff);
2210 time_base += tdiff;
2211 if (debug)
2212 fprintf (outfile, "heap shot end\n");
2213 if (collect_traces) {
2214 HeapShot *hs = thread->current_heap_shot;
2215 if (hs && thread->num_roots) {
2216 /* transfer the root ownershipt to the heapshot */
2217 hs->num_roots = thread->num_roots;
2218 hs->roots = thread->roots;
2219 hs->roots_extra = thread->roots_extra;
2220 hs->roots_types = thread->roots_types;
2221 } else {
2222 free (thread->roots);
2223 free (thread->roots_extra);
2224 free (thread->roots_types);
2225 }
2226 thread->num_roots = 0;
2227 thread->size_roots = 0;
2228 thread->roots = NULL;
2229 thread->roots_extra = NULL;
2230 thread->roots_types = NULL;
2231 heap_shot_resolve_reverse_refs (hs);
2232 heap_shot_mark_objects (hs);
2233 heap_shot_free_objects (hs);
2234 }
2235 thread->current_heap_shot = NULL;
2236 } else if (subtype == TYPE_HEAP_START) {
2237 uint64_t tdiff = decode_uleb128 (p + 1, &p);
2238 LOG_TIME (time_base, tdiff);
2239 time_base += tdiff;
2240 if (debug)
2241 fprintf (outfile, "heap shot start\n");
2242 thread->current_heap_shot = new_heap_shot (time_base);
2243 }
2244 break;
2245 }
2246 case TYPE_MONITOR: {
2247 int event = (*p >> 4) & 0x3;
2248 int has_bt = *p & TYPE_MONITOR_BT;
2249 uint64_t tdiff = decode_uleb128 (p + 1, &p);
2250 intptr_t objdiff = decode_sleb128 (p, &p);
2251 MethodDesc* sframes [8];
2252 MethodDesc** frames = sframes;
2253 int record;
2254 int num_bt = 0;
2255 LOG_TIME (time_base, tdiff);
2256 time_base += tdiff;
2257 record = (!thread_filter || thread_filter == thread->thread_id);
2258 if (!(time_base >= time_from && time_base < time_to))
2259 record = 0;
2260 if (event == MONO_PROFILER_MONITOR_CONTENTION) {
2261 MonitorDesc *mdesc = lookup_monitor (OBJ_ADDR (objdiff));
2262 if (record) {
2263 monitor_contention++;
2264 mdesc->contentions++;
2265 thread->monitor = mdesc;
2266 thread->contention_start = time_base;
2267 }
2268 if (has_bt) {
2269 num_bt = 8;
2270 frames = decode_bt (sframes, &num_bt, p, &p, ptr_base);
2271 if (!frames) {
2272 fprintf (outfile, "Cannot load backtrace\n");
2273 return 0;
2274 }
2275 if (record)
2276 add_trace_methods (frames, num_bt, &mdesc->traces, 1);
2277 } else {
2278 if (record)
2279 add_trace_thread (thread, &mdesc->traces, 1);
2280 }
2281 } else if (event == MONO_PROFILER_MONITOR_FAIL) {
2282 if (record) {
2283 monitor_failed++;
2284 if (thread->monitor && thread->contention_start) {
2285 uint64_t wait_time = time_base - thread->contention_start;
2286 if (wait_time > thread->monitor->max_wait_time)
2287 thread->monitor->max_wait_time = wait_time;
2288 thread->monitor->wait_time += wait_time;
2289 thread->monitor = NULL;
2290 thread->contention_start = 0;
2291 }
2292 }
2293 } else if (event == MONO_PROFILER_MONITOR_DONE) {
2294 if (record) {
2295 monitor_acquired++;
2296 if (thread->monitor && thread->contention_start) {
2297 uint64_t wait_time = time_base - thread->contention_start;
2298 if (wait_time > thread->monitor->max_wait_time)
2299 thread->monitor->max_wait_time = wait_time;
2300 thread->monitor->wait_time += wait_time;
2301 thread->monitor = NULL;
2302 thread->contention_start = 0;
2303 }
2304 }
2305 }
2306 if (debug)
2307 fprintf (outfile, "monitor %s for object %p\n", monitor_ev_name (event), (void*)OBJ_ADDR (objdiff));
2308 if (frames != sframes)
2309 free (frames);
2310 break;
2311 }
2312 case TYPE_EXCEPTION: {
2313 int subtype = *p & 0x70;
2314 int has_bt = *p & TYPE_EXCEPTION_BT;
2315 uint64_t tdiff = decode_uleb128 (p + 1, &p);
2316 MethodDesc* sframes [8];
2317 MethodDesc** frames = sframes;
2318 int record;
2319 LOG_TIME (time_base, tdiff);
2320 time_base += tdiff;
2321 record = (!thread_filter || thread_filter == thread->thread_id);
2322 if (!(time_base >= time_from && time_base < time_to))
2323 record = 0;
2324 if (subtype == TYPE_CLAUSE) {
2325 int clause_type = decode_uleb128 (p, &p);
2326 int clause_num = decode_uleb128 (p, &p);
2327 int64_t ptrdiff = decode_sleb128 (p, &p);
2328 method_base += ptrdiff;
2329 if (record)
2330 clause_summary [clause_type]++;
2331 if (debug)
2332 fprintf (outfile, "clause %s (%d) in method %s\n", clause_name (clause_type), clause_num, lookup_method (method_base)->name);
2333 } else {
2334 intptr_t objdiff = decode_sleb128 (p, &p);
2335 if (record)
2336 throw_count++;
2337 if (has_bt) {
2338 has_bt = 8;
2339 frames = decode_bt (sframes, &has_bt, p, &p, ptr_base);
2340 if (!frames) {
2341 fprintf (outfile, "Cannot load backtrace\n");
2342 return 0;
2343 }
2344 if (record)
2345 add_trace_methods (frames, has_bt, &exc_traces, 1);
2346 } else {
2347 if (record)
2348 add_trace_thread (thread, &exc_traces, 1);
2349 }
2350 if (frames != sframes)
2351 free (frames);
2352 if (debug)
2353 fprintf (outfile, "throw %p\n", (void*)OBJ_ADDR (objdiff));
2354 }
2355 break;
2356 }
2357 case TYPE_SAMPLE: {
2358 int subtype = *p & 0xf0;
2359 if (subtype == TYPE_SAMPLE_HIT) {
2360 int i;
2361 int sample_type = decode_uleb128 (p + 1, &p);
2362 uint64_t tstamp = decode_uleb128 (p, &p);
2363 int count = decode_uleb128 (p, &p);
2364 for (i = 0; i < count; ++i) {
2365 uintptr_t ip = ptr_base + decode_sleb128 (p, &p);
2366 if ((tstamp >= time_from && tstamp < time_to))
2367 add_stat_sample (sample_type, ip);
2368 if (debug)
2369 fprintf (outfile, "sample hit, type: %d at %p\n", sample_type, (void*)ip);
2370 }
2371 if (ctx->data_version > 5) {
2372 count = decode_uleb128 (p, &p);
2373 for (i = 0; i < count; ++i) {
2374 MethodDesc *method;
2375 int64_t ptrdiff = decode_sleb128 (p, &p);
2376 int il_offset = decode_sleb128 (p, &p);
2377 int native_offset = decode_sleb128 (p, &p);
2378 method_base += ptrdiff;
2379 method = lookup_method (method_base);
2380 if (debug)
2381 fprintf (outfile, "sample hit bt %d: %s at IL offset %d (native: %d)\n", i, method->name, il_offset, native_offset);
2382 }
2383 }
2384 } else if (subtype == TYPE_SAMPLE_USYM) {
2385 /* un unmanaged symbol description */
2386 uintptr_t addr = ptr_base + decode_sleb128 (p + 1, &p);
2387 uintptr_t size = decode_uleb128 (p, &p);
2388 char *name;
2389 name = pstrdup ((char*)p);
2390 add_unmanaged_symbol (addr, name, size);
2391 if (debug)
2392 fprintf (outfile, "unmanaged symbol %s at %p\n", name, (void*)addr);
2393 while (*p) p++;
2394 p++;
2395 } else if (subtype == TYPE_SAMPLE_UBIN) {
2396 /* un unmanaged binary loaded in memory */
2397 uint64_t tdiff = decode_uleb128 (p + 1, &p);
2398 uintptr_t addr = decode_sleb128 (p, &p);
2399 uint64_t offset G_GNUC_UNUSED = decode_uleb128 (p, &p);
2400 uintptr_t size = decode_uleb128 (p, &p);
2401 char *name;
2402 LOG_TIME (time_base, tdiff);
2403 time_base += tdiff;
2404 name = pstrdup ((char*)p);
2405 add_unmanaged_binary (addr, name, size);
2406 if (debug)
2407 fprintf (outfile, "unmanaged binary %s at %p\n", name, (void*)addr);
2408 while (*p) p++;
2409 p++;
2410 } else if (subtype == TYPE_SAMPLE_COUNTERS_DESC) {
2411 uint64_t i, len = decode_uleb128 (p + 1, &p);
2412 for (i = 0; i < len; i++) {
2413 uint64_t type, unit, variance, index;
2414 uint64_t section = decode_uleb128 (p, &p);
2415 char *name = pstrdup ((char*)p);
2416 while (*p++);
2417 type = decode_uleb128 (p, &p);
2418 unit = decode_uleb128 (p, &p);
2419 variance = decode_uleb128 (p, &p);
2420 index = decode_uleb128 (p, &p);
2421 add_counter ((int)section, name, (int)type, (int)unit, (int)variance, (int)index);
2422 }
2423 } else if (subtype == TYPE_SAMPLE_COUNTERS) {
2424 int i;
2425 CounterValue *value, *previous = NULL;
2426 CounterList *list;
2427 uint64_t timestamp = decode_uleb128 (p + 1, &p);
2428 uint64_t time_between = timestamp / 1000 * 1000 * 1000 * 1000 + startup_time;
2429 while (1) {
2430 uint64_t type, index = decode_uleb128 (p, &p);
2431 if (index == 0)
2432 break;
2433
2434 for (list = counters; list; list = list->next) {
2435 if (list->counter->index == (int)index) {
2436 previous = list->counter->values_last;
2437 break;
2438 }
2439 }
2440
2441 type = decode_uleb128 (p, &p);
2442
2443 value = calloc (1, sizeof (CounterValue));
2444 value->timestamp = timestamp;
2445
2446 switch (type) {
2447 case MONO_COUNTER_INT:
2448 #if SIZEOF_VOID_P == 4
2449 case MONO_COUNTER_WORD:
2450 #endif
2451 value->buffer = malloc (sizeof (int32_t));
2452 *(int32_t*)value->buffer = (int32_t)decode_sleb128 (p, &p) + (previous ? (*(int32_t*)previous->buffer) : 0);
2453 break;
2454 case MONO_COUNTER_UINT:
2455 value->buffer = malloc (sizeof (uint32_t));
2456 *(uint32_t*)value->buffer = (uint32_t)decode_uleb128 (p, &p) + (previous ? (*(uint32_t*)previous->buffer) : 0);
2457 break;
2458 case MONO_COUNTER_LONG:
2459 #if SIZEOF_VOID_P == 8
2460 case MONO_COUNTER_WORD:
2461 #endif
2462 case MONO_COUNTER_TIME_INTERVAL:
2463 value->buffer = malloc (sizeof (int64_t));
2464 *(int64_t*)value->buffer = (int64_t)decode_sleb128 (p, &p) + (previous ? (*(int64_t*)previous->buffer) : 0);
2465 break;
2466 case MONO_COUNTER_ULONG:
2467 value->buffer = malloc (sizeof (uint64_t));
2468 *(uint64_t*)value->buffer = (uint64_t)decode_uleb128 (p, &p) + (previous ? (*(uint64_t*)previous->buffer) : 0);
2469 break;
2470 case MONO_COUNTER_DOUBLE:
2471 value->buffer = malloc (sizeof (double));
2472 #if TARGET_BYTE_ORDER == G_LITTLE_ENDIAN
2473 for (i = 0; i < sizeof (double); i++)
2474 #else
2475 for (i = sizeof (double) - 1; i >= 0; i--)
2476 #endif
2477 value->buffer[i] = *p++;
2478 break;
2479 case MONO_COUNTER_STRING:
2480 if (*p++ == 0) {
2481 value->buffer = NULL;
2482 } else {
2483 value->buffer = (unsigned char*) pstrdup ((char*)p);
2484 while (*p++);
2485 }
2486 break;
2487 }
2488 if (time_between >= time_from && time_between <= time_to)
2489 add_counter_value (index, value);
2490 }
2491 } else {
2492 return 0;
2493 }
2494 break;
2495 }
2496 default:
2497 fprintf (outfile, "unhandled profiler event: 0x%x at file offset: %llu + %lld (len: %d\n)\n", *p, (unsigned long long) file_offset, (long long) (p - ctx->buf), len);
2498 exit (1);
2499 }
2500 }
2501 thread->last_time = time_base;
2502 for (i = 0; i < thread->stack_id; ++i)
2503 thread->stack [i]->recurse_count = 0;
2504 return 1;
2505 }
2506
2507 static ProfContext*
2508 load_file (char *name)
2509 {
2510 unsigned char *p;
2511 ProfContext *ctx = calloc (sizeof (ProfContext), 1);
2512 if (strcmp (name, "-") == 0)
2513 ctx->file = stdin;
2514 else
2515 ctx->file = fopen (name, "rb");
2516 if (!ctx->file) {
2517 printf ("Cannot open file: %s\n", name);
2518 exit (1);
2519 }
2520 #if defined (HAVE_SYS_ZLIB)
2521 if (ctx->file != stdin)
2522 ctx->gzfile = gzdopen (fileno (ctx->file), "rb");
2523 #endif
2524 if (!load_data (ctx, 32))
2525 return NULL;
2526 p = ctx->buf;
2527 if (read_int32 (p) != LOG_HEADER_ID || p [6] > LOG_DATA_VERSION)
2528 return NULL;
2529 ctx->version_major = p [4];
2530 ctx->version_minor = p [5];
2531 ctx->data_version = p [6];
2532 /* reading 64 bit files on 32 bit systems not supported yet */
2533 if (p [7] > sizeof (void*))
2534 return NULL;
2535 if (read_int32 (p + 20)) /* flags must be 0 */
2536 return NULL;
2537 ctx->startup_time = read_int64 (p + 8);
2538 ctx->timer_overhead = read_int32 (p + 16);
2539 ctx->pid = read_int32 (p + 24);
2540 ctx->port = read_int16 (p + 28);
2541 return ctx;
2542 }
2543
2544 enum {
2545 ALLOC_SORT_BYTES,
2546 ALLOC_SORT_COUNT
2547 };
2548 static int alloc_sort_mode = ALLOC_SORT_BYTES;
2549
2550 static int
2551 compare_class (const void *a, const void *b)
2552 {
2553 ClassDesc *const*A = a;
2554 ClassDesc *const*B = b;
2555 uint64_t vala, valb;
2556 if (alloc_sort_mode == ALLOC_SORT_BYTES) {
2557 vala = (*A)->alloc_size;
2558 valb = (*B)->alloc_size;
2559 } else {
2560 vala = (*A)->allocs;
2561 valb = (*B)->allocs;
2562 }
2563 if (valb == vala)
2564 return 0;
2565 if (valb < vala)
2566 return -1;
2567 return 1;
2568 }
2569
2570 static void
2571 dump_header (ProfContext *ctx)
2572 {
2573 time_t st = ctx->startup_time / 1000;
2574 char *t = ctime (&st);
2575 fprintf (outfile, "\nMono log profiler data\n");
2576 fprintf (outfile, "\tProfiler version: %d.%d\n", ctx->version_major, ctx->version_minor);
2577 fprintf (outfile, "\tData version: %d\n", ctx->data_version);
2578 fprintf (outfile, "\tMean timer overhead: %d nanoseconds\n", ctx->timer_overhead);
2579 fprintf (outfile, "\tProgram startup: %s", t);
2580 if (ctx->pid)
2581 fprintf (outfile, "\tProgram ID: %d\n", ctx->pid);
2582 if (ctx->port)
2583 fprintf (outfile, "\tServer listening on: %d\n", ctx->port);
2584 }
2585
2586 static void
2587 dump_traces (TraceDesc *traces, const char *desc)
2588 {
2589 int j;
2590 if (!show_traces)
2591 return;
2592 if (!traces->count)
2593 return;
2594 sort_context_array (traces);
2595 for (j = 0; j < traces->count; ++j) {
2596 int k;
2597 BackTrace *bt;
2598 bt = traces->traces [j].bt;
2599 if (!bt->count)
2600 continue;
2601 fprintf (outfile, "\t%llu %s from:\n", (unsigned long long) traces->traces [j].count, desc);
2602 for (k = 0; k < bt->count; ++k)
2603 fprintf (outfile, "\t\t%s\n", bt->methods [k]->name);
2604 }
2605 }
2606
2607 static void
2608 dump_threads (ProfContext *ctx)
2609 {
2610 ThreadContext *thread;
2611 fprintf (outfile, "\nThread summary\n");
2612 for (thread = ctx->threads; thread; thread = thread->next) {
2613 fprintf (outfile, "\tThread: %p, name: \"%s\"\n", (void*)thread->thread_id, thread->name? thread->name: "");
2614 }
2615 }
2616
2617 static void
2618 dump_exceptions (void)
2619 {
2620 int i;
2621 fprintf (outfile, "\nException summary\n");
2622 fprintf (outfile, "\tThrows: %llu\n", (unsigned long long) throw_count);
2623 dump_traces (&exc_traces, "throws");
2624 for (i = 0; i <= MONO_EXCEPTION_CLAUSE_FAULT; ++i) {
2625 if (!clause_summary [i])
2626 continue;
2627 fprintf (outfile, "\tExecuted %s clauses: %llu\n", clause_name (i), (unsigned long long) clause_summary [i]);
2628 }
2629 }
2630
2631 static int
2632 compare_monitor (const void *a, const void *b)
2633 {
2634 MonitorDesc *const*A = a;
2635 MonitorDesc *const*B = b;
2636 if ((*B)->wait_time == (*A)->wait_time)
2637 return 0;
2638 if ((*B)->wait_time < (*A)->wait_time)
2639 return -1;
2640 return 1;
2641 }
2642
2643 static void
2644 dump_monitors (void)
2645 {
2646 MonitorDesc **monitors;
2647 int i, j;
2648 if (!num_monitors)
2649 return;
2650 monitors = malloc (sizeof (void*) * num_monitors);
2651 for (i = 0, j = 0; i < SMALL_HASH_SIZE; ++i) {
2652 MonitorDesc *mdesc = monitor_hash [i];
2653 while (mdesc) {
2654 monitors [j++] = mdesc;
2655 mdesc = mdesc->next;
2656 }
2657 }
2658 qsort (monitors, num_monitors, sizeof (void*), compare_monitor);
2659 fprintf (outfile, "\nMonitor lock summary\n");
2660 for (i = 0; i < num_monitors; ++i) {
2661 MonitorDesc *mdesc = monitors [i];
2662 fprintf (outfile, "\tLock object %p: %d contentions\n", (void*)mdesc->objid, (int)mdesc->contentions);
2663 fprintf (outfile, "\t\t%.6f secs total wait time, %.6f max, %.6f average\n",
2664 mdesc->wait_time/1000000000.0, mdesc->max_wait_time/1000000000.0, mdesc->wait_time/1000000000.0/mdesc->contentions);
2665 dump_traces (&mdesc->traces, "contentions");
2666 }
2667 fprintf (outfile, "\tLock contentions: %llu\n", (unsigned long long) monitor_contention);
2668 fprintf (outfile, "\tLock acquired: %llu\n", (unsigned long long) monitor_acquired);
2669 fprintf (outfile, "\tLock failures: %llu\n", (unsigned long long) monitor_failed);
2670 }
2671
2672 static void
2673 dump_gcs (void)
2674 {
2675 int i;
2676 fprintf (outfile, "\nGC summary\n");
2677 fprintf (outfile, "\tGC resizes: %d\n", gc_resizes);
2678 fprintf (outfile, "\tMax heap size: %llu\n", (unsigned long long) max_heap_size);
2679 fprintf (outfile, "\tObject moves: %llu\n", (unsigned long long) gc_object_moves);
2680 for (i = 0; i < 3; ++i) {
2681 if (!gc_info [i].count)
2682 continue;
2683 fprintf (outfile, "\tGen%d collections: %d, max time: %lluus, total time: %lluus, average: %lluus\n",
2684 i, gc_info [i].count,
2685 (unsigned long long) (gc_info [i].max_time / 1000),
2686 (unsigned long long) (gc_info [i].total_time / 1000),
2687 (unsigned long long) (gc_info [i].total_time / gc_info [i].count / 1000));
2688 }
2689 for (i = 0; i < 3; ++i) {
2690 if (!handle_info [i].max_live)
2691 continue;
2692 fprintf (outfile, "\tGC handles %s: created: %llu, destroyed: %llu, max: %llu\n",
2693 get_handle_name (i),
2694 (unsigned long long) (handle_info [i].created),
2695 (unsigned long long) (handle_info [i].destroyed),
2696 (unsigned long long) (handle_info [i].max_live));
2697 dump_traces (&handle_info [i].traces, "created");
2698 }
2699 }
2700
2701 static void
2702 dump_jit (void)
2703 {
2704 int i;
2705 int code_size = 0;
2706 int compiled_methods = 0;
2707 MethodDesc* m;
2708 fprintf (outfile, "\nJIT summary\n");
2709 for (i = 0; i < HASH_SIZE; ++i) {
2710 m = method_hash [i];
2711 for (m = method_hash [i]; m; m = m->next) {
2712 if (!m->code || m->ignore_jit)
2713 continue;
2714 compiled_methods++;
2715 code_size += m->len;
2716 }
2717 }
2718 fprintf (outfile, "\tCompiled methods: %d\n", compiled_methods);
2719 fprintf (outfile, "\tGenerated code size: %d\n", code_size);
2720 }
2721
2722 static void
2723 dump_allocations (void)
2724 {
2725 int i, c;
2726 intptr_t allocs = 0;
2727 uint64_t size = 0;
2728 int header_done = 0;
2729 ClassDesc **classes = malloc (num_classes * sizeof (void*));
2730 ClassDesc *cd;
2731 c = 0;
2732 for (i = 0; i < HASH_SIZE; ++i) {
2733 cd = class_hash [i];
2734 while (cd) {
2735 classes [c++] = cd;
2736 cd = cd->next;
2737 }
2738 }
2739 qsort (classes, num_classes, sizeof (void*), compare_class);
2740 for (i = 0; i < num_classes; ++i) {
2741 cd = classes [i];
2742 if (!cd->allocs)
2743 continue;
2744 allocs += cd->allocs;
2745 size += cd->alloc_size;
2746 if (!header_done++) {
2747 fprintf (outfile, "\nAllocation summary\n");
2748 fprintf (outfile, "%10s %10s %8s Type name\n", "Bytes", "Count", "Average");
2749 }
2750 fprintf (outfile, "%10llu %10zd %8llu %s\n",
2751 (unsigned long long) (cd->alloc_size),
2752 cd->allocs,
2753 (unsigned long long) (cd->alloc_size / cd->allocs),
2754 cd->name);
2755 dump_traces (&cd->traces, "bytes");
2756 }
2757 if (allocs)
2758 fprintf (outfile, "Total memory allocated: %llu bytes in %zd objects\n", (unsigned long long) size, allocs);
2759 }
2760
2761 enum {
2762 METHOD_SORT_TOTAL,
2763 METHOD_SORT_SELF,
2764 METHOD_SORT_CALLS
2765 };
2766
2767 static int method_sort_mode = METHOD_SORT_TOTAL;
2768
2769 static int
2770 compare_method (const void *a, const void *b)
2771 {
2772 MethodDesc *const*A = a;
2773 MethodDesc *const*B = b;
2774 uint64_t vala, valb;
2775 if (method_sort_mode == METHOD_SORT_SELF) {
2776 vala = (*A)->self_time;
2777 valb = (*B)->self_time;
2778 } else if (method_sort_mode == METHOD_SORT_CALLS) {
2779 vala = (*A)->calls;
2780 valb = (*B)->calls;
2781 } else {
2782 vala = (*A)->total_time;
2783 valb = (*B)->total_time;
2784 }
2785 if (vala == valb)
2786 return 0;
2787 if (valb < vala)
2788 return -1;
2789 return 1;
2790 }
2791
2792 static void
2793 dump_metadata (void)
2794 {
2795 fprintf (outfile, "\nMetadata summary\n");
2796 fprintf (outfile, "\tLoaded images: %d\n", num_images);
2797 if (verbose) {
2798 ImageDesc *image;
2799 int i;
2800 for (i = 0; i < SMALL_HASH_SIZE; ++i) {
2801 image = image_hash [i];
2802 while (image) {
2803 fprintf (outfile, "\t\t%s\n", image->filename);
2804 image = image->next;
2805 }
2806 }
2807 }
2808
2809 }
2810
2811 static void
2812 dump_methods (void)
2813 {
2814 int i, c;
2815 uint64_t calls = 0;
2816 int header_done = 0;
2817 MethodDesc **methods = malloc (num_methods * sizeof (void*));
2818 MethodDesc *cd;
2819 c = 0;
2820 for (i = 0; i < HASH_SIZE; ++i) {
2821 cd = method_hash [i];
2822 while (cd) {
2823 cd->total_time = cd->self_time + cd->callee_time;
2824 methods [c++] = cd;
2825 cd = cd->next;
2826 }
2827 }
2828 qsort (methods, num_methods, sizeof (void*), compare_method);
2829 for (i = 0; i < num_methods; ++i) {
2830 uint64_t msecs;
2831 uint64_t smsecs;
2832 cd = methods [i];
2833 if (!cd->calls)
2834 continue;
2835 calls += cd->calls;
2836 msecs = cd->total_time / 1000000;
2837 smsecs = (cd->total_time - cd->callee_time) / 1000000;
2838 if (!msecs && !verbose)
2839 continue;
2840 if (!header_done++) {
2841 fprintf (outfile, "\nMethod call summary\n");
2842 fprintf (outfile, "%8s %8s %10s Method name\n", "Total(ms)", "Self(ms)", "Calls");
2843 }
2844 fprintf (outfile, "%8llu %8llu %10llu %s\n",
2845 (unsigned long long) (msecs),
2846 (unsigned long long) (smsecs),
2847 (unsigned long long) (cd->calls),
2848 cd->name);
2849 dump_traces (&cd->traces, "calls");
2850 }
2851 if (calls)
2852 fprintf (outfile, "Total calls: %llu\n", (unsigned long long) calls);
2853 }
2854
2855 static int
2856 compare_heap_class (const void *a, const void *b)
2857 {
2858 HeapClassDesc *const*A = a;
2859 HeapClassDesc *const*B = b;
2860 uint64_t vala, valb;
2861 if (alloc_sort_mode == ALLOC_SORT_BYTES) {
2862 vala = (*A)->total_size;
2863 valb = (*B)->total_size;
2864 } else {
2865 vala = (*A)->count;
2866 valb = (*B)->count;
2867 }
2868 if (valb == vala)
2869 return 0;
2870 if (valb < vala)
2871 return -1;
2872 return 1;
2873 }
2874
2875 static int
2876 compare_rev_class (const void *a, const void *b)
2877 {
2878 const HeapClassRevRef *A = a;
2879 const HeapClassRevRef *B = b;
2880 if (B->count == A->count)
2881 return 0;
2882 if (B->count < A->count)
2883 return -1;
2884 return 1;
2885 }
2886
2887 static void
2888 dump_rev_claases (HeapClassRevRef *revs, int count)
2889 {
2890 int j;
2891 if (!show_traces)
2892 return;
2893 if (!count)
2894 return;
2895 for (j = 0; j < count; ++j) {
2896 HeapClassDesc *cd = revs [j].klass;
2897 fprintf (outfile, "\t\t%llu references from: %s\n",
2898 (unsigned long long) (revs [j].count),
2899 cd->klass->name);
2900 }
2901 }
2902
2903 static void
2904 heap_shot_summary (HeapShot *hs, int hs_num, HeapShot *last_hs)
2905 {
2906 uint64_t size = 0;
2907 uint64_t count = 0;
2908 int ccount = 0;
2909 int i;
2910 HeapClassDesc *cd;
2911 HeapClassDesc **sorted;
2912 sorted = malloc (sizeof (void*) * hs->class_count);
2913 for (i = 0; i < hs->hash_size; ++i) {
2914 cd = hs->class_hash [i];
2915 if (!cd)
2916 continue;
2917 count += cd->count;
2918 size += cd->total_size;
2919 sorted [ccount++] = cd;
2920 }
2921 hs->sorted = sorted;
2922 qsort (sorted, ccount, sizeof (void*), compare_heap_class);
2923 fprintf (outfile, "\n\tHeap shot %d at %.3f secs: size: %llu, object count: %llu, class count: %d, roots: %zd\n",
2924 hs_num,
2925 (hs->timestamp - startup_time)/1000000000.0,
2926 (unsigned long long) (size),
2927 (unsigned long long) (count),
2928 ccount, hs->num_roots);
2929 if (!verbose && ccount > 30)
2930 ccount = 30;
2931 fprintf (outfile, "\t%10s %10s %8s Class name\n", "Bytes", "Count", "Average");
2932 for (i = 0; i < ccount; ++i) {
2933 HeapClassRevRef *rev_sorted;
2934 int j, k;
2935 HeapClassDesc *ocd = NULL;
2936 cd = sorted [i];
2937 if (last_hs)
2938 ocd = heap_class_lookup (last_hs, cd->klass);
2939 fprintf (outfile, "\t%10llu %10llu %8llu %s",
2940 (unsigned long long) (cd->total_size),
2941 (unsigned long long) (cd->count),
2942 (unsigned long long) (cd->total_size / cd->count),
2943 cd->klass->name);
2944 if (ocd) {
2945 int64_t bdiff = cd->total_size - ocd->total_size;
2946 int64_t cdiff = cd->count - ocd->count;
2947 fprintf (outfile, " (bytes: %+lld, count: %+lld)\n", (long long) bdiff, (long long) cdiff);
2948 } else {
2949 fprintf (outfile, "\n");
2950 }
2951 if (!collect_traces)
2952 continue;
2953 rev_sorted = malloc (cd->rev_count * sizeof (HeapClassRevRef));
2954 k = 0;
2955 for (j = 0; j < cd->rev_hash_size; ++j) {
2956 if (cd->rev_hash [j].klass)
2957 rev_sorted [k++] = cd->rev_hash [j];
2958 }
2959 assert (cd->rev_count == k);
2960 qsort (rev_sorted, cd->rev_count, sizeof (HeapClassRevRef), compare_rev_class);
2961 if (cd->root_references)
2962 fprintf (outfile, "\t\t%zd root references (%zd pinning)\n", cd->root_references, cd->pinned_references);
2963 dump_rev_claases (rev_sorted, cd->rev_count);
2964 free (rev_sorted);
2965 }
2966 free (sorted);
2967 }
2968
2969 static int
2970 compare_heap_shots (const void *a, const void *b)
2971 {
2972 HeapShot *const*A = a;
2973 HeapShot *const*B = b;
2974 if ((*B)->timestamp == (*A)->timestamp)
2975 return 0;
2976 if ((*B)->timestamp > (*A)->timestamp)
2977 return -1;
2978 return 1;
2979 }
2980
2981 static void
2982 dump_heap_shots (void)
2983 {
2984 HeapShot **hs_sorted;
2985 HeapShot *hs;
2986 HeapShot *last_hs = NULL;
2987 int i;
2988 if (!heap_shots)
2989 return;
2990 hs_sorted = malloc (num_heap_shots * sizeof (void*));
2991 fprintf (outfile, "\nHeap shot summary\n");
2992 i = 0;
2993 for (hs = heap_shots; hs; hs = hs->next)
2994 hs_sorted [i++] = hs;
2995 qsort (hs_sorted, num_heap_shots, sizeof (void*), compare_heap_shots);
2996 for (i = 0; i < num_heap_shots; ++i) {
2997 hs = hs_sorted [i];
2998 heap_shot_summary (hs, i, last_hs);
2999 last_hs = hs;
3000 }
3001 }
3002
3003 static void
3004 flush_context (ProfContext *ctx)
3005 {
3006 ThreadContext *thread;
3007 /* FIXME: sometimes there are leftovers: indagate */
3008 for (thread = ctx->threads; thread; thread = thread->next) {
3009 while (thread->stack_id) {
3010 if (debug)
3011 fprintf (outfile, "thread %p has %d items on stack\n", (void*)thread->thread_id, thread->stack_id);
3012 pop_method (thread, thread->stack [thread->stack_id - 1], thread->last_time);
3013 }
3014 }
3015 }
3016
3017 static const char *reports = "header,jit,gc,sample,alloc,call,metadata,exception,monitor,thread,heapshot,counters";
3018
3019 static const char*
3020 match_option (const char *p, const char *opt)
3021 {
3022 int len = strlen (opt);
3023 if (strncmp (p, opt, len) == 0) {
3024 if (p [len] == ',')
3025 len++;
3026 return p + len;
3027 }
3028 return p;
3029 }
3030
3031 static int
3032 print_reports (ProfContext *ctx, const char *reps, int parse_only)
3033 {
3034 const char *opt;
3035 const char *p;
3036 for (p = reps; *p; p = opt) {
3037 if ((opt = match_option (p, "header")) != p) {
3038 if (!parse_only)
3039 dump_header (ctx);
3040 continue;
3041 }
3042 if ((opt = match_option (p, "thread")) != p) {
3043 if (!parse_only)
3044 dump_threads (ctx);
3045 continue;
3046 }
3047 if ((opt = match_option (p, "gc")) != p) {
3048 if (!parse_only)
3049 dump_gcs ();
3050 continue;
3051 }
3052 if ((opt = match_option (p, "jit")) != p) {
3053 if (!parse_only)
3054 dump_jit ();
3055 continue;
3056 }
3057 if ((opt = match_option (p, "alloc")) != p) {
3058 if (!parse_only)
3059 dump_allocations ();
3060 continue;
3061 }
3062 if ((opt = match_option (p, "call")) != p) {
3063 if (!parse_only)
3064 dump_methods ();
3065 continue;
3066 }
3067 if ((opt = match_option (p, "metadata")) != p) {
3068 if (!parse_only)
3069 dump_metadata ();
3070 continue;
3071 }
3072 if ((opt = match_option (p, "exception")) != p) {
3073 if (!parse_only)
3074 dump_exceptions ();
3075 continue;
3076 }
3077 if ((opt = match_option (p, "monitor")) != p) {
3078 if (!parse_only)
3079 dump_monitors ();
3080 continue;
3081 }
3082 if ((opt = match_option (p, "heapshot")) != p) {
3083 if (!parse_only)
3084 dump_heap_shots ();
3085 continue;
3086 }
3087 if ((opt = match_option (p, "sample")) != p) {
3088 if (!parse_only)
3089 dump_samples ();
3090 continue;
3091 }
3092 if ((opt = match_option (p, "counters")) != p) {
3093 if (!parse_only)
3094 dump_counters ();
3095 continue;
3096 }
3097 return 0;
3098 }
3099 return 1;
3100 }
3101
3102 static int
3103 add_find_spec (const char *p)
3104 {
3105 if (p [0] == 'S' && p [1] == ':') {
3106 char *vale;
3107 find_size = strtoul (p + 2, &vale, 10);
3108 return 1;
3109 } else if (p [0] == 'T' && p [1] == ':') {
3110 find_name = p + 2;
3111 return 1;
3112 }
3113 return 0;
3114 }
3115
3116 static void
3117 usage (void)
3118 {
3119 printf ("Mono log profiler report version %d.%d\n", LOG_VERSION_MAJOR, LOG_VERSION_MINOR);
3120 printf ("Usage: mprof-report [OPTIONS] FILENAME\n");
3121 printf ("FILENAME can be '-' to read from standard input.\n");
3122 printf ("Options:\n");
3123 printf ("\t--help display this help\n");
3124 printf ("\t--out=FILE write to FILE instead of stdout\n");
3125 printf ("\t--traces collect and show backtraces\n");
3126 printf ("\t--maxframes=NUM limit backtraces to NUM entries\n");
3127 printf ("\t--reports=R1[,R2...] print the specified reports. Defaults are:\n");
3128 printf ("\t %s\n", reports);
3129 printf ("\t--method-sort=MODE sort methods according to MODE: total, self, calls\n");
3130 printf ("\t--alloc-sort=MODE sort allocations according to MODE: bytes, count\n");
3131 printf ("\t--counters-sort=MODE sort counters according to MODE: time, category\n");
3132 printf ("\t only accessible in verbose mode\n");
3133 printf ("\t--track=OB1[,OB2...] track what happens to objects OBJ1, O2 etc.\n");
3134 printf ("\t--find=FINDSPEC find and track objects matching FINFSPEC, where FINDSPEC is:\n");
3135 printf ("\t S:minimum_size or T:partial_name\n");
3136 printf ("\t--thread=THREADID consider just the data for thread THREADID\n");
3137 printf ("\t--time=FROM-TO consider data FROM seconds from startup up to TO seconds\n");
3138 printf ("\t--verbose increase verbosity level\n");
3139 printf ("\t--debug display decoding debug info for mprof-report devs\n");
3140 }
3141
3142 int
3143 main (int argc, char *argv[])
3144 {
3145 ProfContext *ctx;
3146 int i;
3147 outfile = stdout;
3148 for (i = 1; i < argc; ++i) {
3149 if (strcmp ("--debug", argv [i]) == 0) {
3150 debug++;
3151 } else if (strcmp ("--help", argv [i]) == 0) {
3152 usage ();
3153 return 0;
3154 } else if (strncmp ("--alloc-sort=", argv [i], 13) == 0) {
3155 const char *val = argv [i] + 13;
3156 if (strcmp (val, "bytes") == 0) {
3157 alloc_sort_mode = ALLOC_SORT_BYTES;
3158 } else if (strcmp (val, "count") == 0) {
3159 alloc_sort_mode = ALLOC_SORT_COUNT;
3160 } else {
3161 usage ();
3162 return 1;
3163 }
3164 } else if (strncmp ("--method-sort=", argv [i], 14) == 0) {
3165 const char *val = argv [i] + 14;
3166 if (strcmp (val, "total") == 0) {
3167 method_sort_mode = METHOD_SORT_TOTAL;
3168 } else if (strcmp (val, "self") == 0) {
3169 method_sort_mode = METHOD_SORT_SELF;
3170 } else if (strcmp (val, "calls") == 0) {
3171 method_sort_mode = METHOD_SORT_CALLS;
3172 } else {
3173 usage ();
3174 return 1;
3175 }
3176 } else if (strncmp ("--counters-sort=", argv [i], 16) == 0) {
3177 const char *val = argv [i] + 16;
3178 if (strcmp (val, "time") == 0) {
3179 counters_sort_mode = COUNTERS_SORT_TIME;
3180 } else if (strcmp (val, "category") == 0) {
3181 counters_sort_mode = COUNTERS_SORT_CATEGORY;
3182 } else {
3183 usage ();
3184 return 1;
3185 }
3186 } else if (strncmp ("--reports=", argv [i], 10) == 0) {
3187 const char *val = argv [i] + 10;
3188 if (!print_reports (NULL, val, 1)) {
3189 usage ();
3190 return 1;
3191 }
3192 reports = val;
3193 } else if (strncmp ("--out=", argv [i], 6) == 0) {
3194 const char *val = argv [i] + 6;
3195 outfile = fopen (val, "w");
3196 if (!outfile) {
3197 printf ("Cannot open output file: %s\n", val);
3198 return 1;
3199 }
3200 } else if (strncmp ("--maxframes=", argv [i], 12) == 0) {
3201 const char *val = argv [i] + 12;
3202 char *vale;
3203 trace_max = strtoul (val, &vale, 10);
3204 } else if (strncmp ("--find=", argv [i], 7) == 0) {
3205 const char *val = argv [i] + 7;
3206 if (!add_find_spec (val)) {
3207 usage ();
3208 return 1;
3209 }
3210 } else if (strncmp ("--track=", argv [i], 8) == 0) {
3211 const char *val = argv [i] + 8;
3212 char *vale;
3213 while (*val) {
3214 uintptr_t tracked_obj;
3215 if (*val == ',') {
3216 val++;
3217 continue;
3218 }
3219 tracked_obj = strtoul (val, &vale, 0);
3220 found_object (tracked_obj);
3221 val = vale;
3222 }
3223 } else if (strncmp ("--thread=", argv [i], 9) == 0) {
3224 const char *val = argv [i] + 9;
3225 char *vale;
3226 thread_filter = strtoul (val, &vale, 0);
3227 } else if (strncmp ("--time=", argv [i], 7) == 0) {
3228 char *val = pstrdup (argv [i] + 7);
3229 double from_secs, to_secs;
3230 char *top = strchr (val, '-');
3231 if (!top) {
3232 usage ();
3233 return 1;
3234 }
3235 *top++ = 0;
3236 from_secs = atof (val);
3237 to_secs = atof (top);
3238 free (val);
3239 if (from_secs > to_secs) {
3240 usage ();
3241 return 1;
3242 }
3243 time_from = from_secs * 1000000000;
3244 time_to = to_secs * 1000000000;
3245 use_time_filter = 1;
3246 } else if (strcmp ("--verbose", argv [i]) == 0) {
3247 verbose++;
3248 } else if (strcmp ("--traces", argv [i]) == 0) {
3249 show_traces = 1;
3250 collect_traces = 1;
3251 } else {
3252 break;
3253 }
3254 }
3255 if (i >= argc) {
3256 usage ();
3257 return 2;
3258 }
3259 ctx = load_file (argv [i]);
3260 if (!ctx) {
3261 printf ("Not a log profiler data file (or unsupported version).\n");
3262 return 1;
3263 }
3264 while (decode_buffer (ctx));
3265 flush_context (ctx);
3266 if (num_tracked_objects)
3267 return 0;
3268 print_reports (ctx, reports, 0);
3269 return 0;
3270 }
3271
Mirror of the official Mono project git repository