?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2007-04-06 Andreas Faerber <andreas.faerber@web.de>
[mono.git] / mono / metadata / profiler.c
blob36ec3a382a99560c7b377530c13e6bf520655d70
1 /*
2 * profiler.c: Profiler interface for Mono
3 *
4 * Author:
5 * Paolo Molaro (lupus@ximian.com)
6 *
7 * (C) 2001-2003 Ximian, Inc.
8 * (C) 2003-2006 Novell, Inc.
9 */
10
11 #include "config.h"
12 #include "mono/metadata/profiler-private.h"
13 #include "mono/metadata/debug-helpers.h"
14 #include "mono/metadata/mono-debug.h"
15 #include "mono/metadata/debug-mono-symfile.h"
16 #include "mono/metadata/metadata-internals.h"
17 #include "mono/metadata/class-internals.h"
18 #include "mono/metadata/domain-internals.h"
19 #include "mono/metadata/gc-internal.h"
20 #include "mono/io-layer/io-layer.h"
21 #include "mono/utils/mono-dl.h"
22 #include <string.h>
23 #include <unistd.h>
24 #include <sys/time.h>
25 #ifdef HAVE_BACKTRACE_SYMBOLS
26 #include <execinfo.h>
27 #endif
28
29 static MonoProfiler * current_profiler = NULL;
30
31 static MonoProfileAppDomainFunc domain_start_load;
32 static MonoProfileAppDomainResult domain_end_load;
33 static MonoProfileAppDomainFunc domain_start_unload;
34 static MonoProfileAppDomainFunc domain_end_unload;
35
36 static MonoProfileAssemblyFunc assembly_start_load;
37 static MonoProfileAssemblyResult assembly_end_load;
38 static MonoProfileAssemblyFunc assembly_start_unload;
39 static MonoProfileAssemblyFunc assembly_end_unload;
40
41 static MonoProfileModuleFunc module_start_load;
42 static MonoProfileModuleResult module_end_load;
43 static MonoProfileModuleFunc module_start_unload;
44 static MonoProfileModuleFunc module_end_unload;
45
46 static MonoProfileClassFunc class_start_load;
47 static MonoProfileClassResult class_end_load;
48 static MonoProfileClassFunc class_start_unload;
49 static MonoProfileClassFunc class_end_unload;
50
51 static MonoProfileMethodFunc jit_start;
52 static MonoProfileMethodResult jit_end;
53 static MonoProfileJitResult jit_end2;
54 static MonoProfileMethodResult man_unman_transition;
55 static MonoProfileAllocFunc allocation_cb;
56 static MonoProfileStatFunc statistical_cb;
57 static MonoProfileMethodFunc method_enter;
58 static MonoProfileMethodFunc method_leave;
59
60 static MonoProfileThreadFunc thread_start;
61 static MonoProfileThreadFunc thread_end;
62
63 static MonoProfileCoverageFilterFunc coverage_filter_cb;
64
65 static MonoProfileFunc shutdown_callback;
66
67 static MonoProfileGCFunc gc_event;
68 static MonoProfileGCResizeFunc gc_heap_resize;
69
70 #define mono_profiler_coverage_lock() EnterCriticalSection (&profiler_coverage_mutex)
71 #define mono_profiler_coverage_unlock() LeaveCriticalSection (&profiler_coverage_mutex)
72 static CRITICAL_SECTION profiler_coverage_mutex;
73
74 /* this is directly accessible to other mono libs. */
75 MonoProfileFlags mono_profiler_events;
76
77 /**
78 * mono_profiler_install:
79 * @prof: a MonoProfiler structure pointer, or a pointer to a derived structure.
80 * @callback: the function to invoke at shutdown
81 *
82 * Use mono_profiler_install to activate profiling in the Mono runtime.
83 * Typically developers of new profilers will create a new structure whose
84 * first field is a MonoProfiler and put any extra information that they need
85 * to access from the various profiling callbacks there.
86 *
87 */
88 void
89 mono_profiler_install (MonoProfiler *prof, MonoProfileFunc callback)
90 {
91 if (current_profiler)
92 g_error ("profiler already setup");
93 current_profiler = prof;
94 shutdown_callback = callback;
95 InitializeCriticalSection (&profiler_coverage_mutex);
96 }
97
98 /**
99 * mono_profiler_set_events:
100 * @events: an ORed set of values made up of MONO_PROFILER_ flags
101 *
102 * The events descriped in the @events argument is a set of flags
103 * that represent which profiling events must be triggered. For
104 * example if you have registered a set of methods for tracking
105 * JIT compilation start and end with mono_profiler_install_jit_compile,
106 * you will want to pass the MONO_PROFILE_JIT_COMPILATION flag to
107 * this routine.
108 *
109 * You can call mono_profile_set_events more than once and you can
110 * do this at runtime to modify which methods are invoked.
111 */
112 void
113 mono_profiler_set_events (MonoProfileFlags events)
114 {
115 mono_profiler_events = events;
116 }
117
118 /**
119 * mono_profiler_get_events:
120 *
121 * Returns a list of active events that will be intercepted.
122 */
123 MonoProfileFlags
124 mono_profiler_get_events (void)
125 {
126 return mono_profiler_events;
127 }
128
129 /**
130 * mono_profiler_install_enter_leave:
131 * @enter: the routine to be called on each method entry
132 * @fleave: the routine to be called each time a method returns
133 *
134 * Use this routine to install routines that will be called everytime
135 * a method enters and leaves. The routines will receive as an argument
136 * the MonoMethod representing the method that is entering or leaving.
137 */
138 void
139 mono_profiler_install_enter_leave (MonoProfileMethodFunc enter, MonoProfileMethodFunc fleave)
140 {
141 method_enter = enter;
142 method_leave = fleave;
143 }
144
145 /**
146 * mono_profiler_install_jit_compile:
147 * @start: the routine to be called when the JIT process starts.
148 * @end: the routine to be called when the JIT process ends.
149 *
150 * Use this routine to install routines that will be called when JIT
151 * compilation of a method starts and completes.
152 */
153 void
154 mono_profiler_install_jit_compile (MonoProfileMethodFunc start, MonoProfileMethodResult end)
155 {
156 jit_start = start;
157 jit_end = end;
158 }
159
160 void
161 mono_profiler_install_jit_end (MonoProfileJitResult end)
162 {
163 jit_end2 = end;
164 }
165
166 void
167 mono_profiler_install_thread (MonoProfileThreadFunc start, MonoProfileThreadFunc end)
168 {
169 thread_start = start;
170 thread_end = end;
171 }
172
173 void
174 mono_profiler_install_transition (MonoProfileMethodResult callback)
175 {
176 man_unman_transition = callback;
177 }
178
179 void
180 mono_profiler_install_allocation (MonoProfileAllocFunc callback)
181 {
182 allocation_cb = callback;
183 }
184
185 void
186 mono_profiler_install_statistical (MonoProfileStatFunc callback)
187 {
188 statistical_cb = callback;
189 }
190
191 void
192 mono_profiler_install_coverage_filter (MonoProfileCoverageFilterFunc callback)
193 {
194 coverage_filter_cb = callback;
195 }
196
197 void
198 mono_profiler_install_appdomain (MonoProfileAppDomainFunc start_load, MonoProfileAppDomainResult end_load,
199 MonoProfileAppDomainFunc start_unload, MonoProfileAppDomainFunc end_unload)
200
201 {
202 domain_start_load = start_load;
203 domain_end_load = end_load;
204 domain_start_unload = start_unload;
205 domain_end_unload = end_unload;
206 }
207
208 void
209 mono_profiler_install_assembly (MonoProfileAssemblyFunc start_load, MonoProfileAssemblyResult end_load,
210 MonoProfileAssemblyFunc start_unload, MonoProfileAssemblyFunc end_unload)
211 {
212 assembly_start_load = start_load;
213 assembly_end_load = end_load;
214 assembly_start_unload = start_unload;
215 assembly_end_unload = end_unload;
216 }
217
218 void
219 mono_profiler_install_module (MonoProfileModuleFunc start_load, MonoProfileModuleResult end_load,
220 MonoProfileModuleFunc start_unload, MonoProfileModuleFunc end_unload)
221 {
222 module_start_load = start_load;
223 module_end_load = end_load;
224 module_start_unload = start_unload;
225 module_end_unload = end_unload;
226 }
227
228 void
229 mono_profiler_install_class (MonoProfileClassFunc start_load, MonoProfileClassResult end_load,
230 MonoProfileClassFunc start_unload, MonoProfileClassFunc end_unload)
231 {
232 class_start_load = start_load;
233 class_end_load = end_load;
234 class_start_unload = start_unload;
235 class_end_unload = end_unload;
236 }
237
238 void
239 mono_profiler_method_enter (MonoMethod *method)
240 {
241 if ((mono_profiler_events & MONO_PROFILE_ENTER_LEAVE) && method_enter)
242 method_enter (current_profiler, method);
243 }
244
245 void
246 mono_profiler_method_leave (MonoMethod *method)
247 {
248 if ((mono_profiler_events & MONO_PROFILE_ENTER_LEAVE) && method_leave)
249 method_leave (current_profiler, method);
250 }
251
252 void
253 mono_profiler_method_jit (MonoMethod *method)
254 {
255 if ((mono_profiler_events & MONO_PROFILE_JIT_COMPILATION) && jit_start)
256 jit_start (current_profiler, method);
257 }
258
259 void
260 mono_profiler_method_end_jit (MonoMethod *method, MonoJitInfo* jinfo, int result)
261 {
262 if ((mono_profiler_events & MONO_PROFILE_JIT_COMPILATION)) {
263 if (jit_end)
264 jit_end (current_profiler, method, result);
265 if (jit_end2)
266 jit_end2 (current_profiler, method, jinfo, result);
267 }
268 }
269
270 void
271 mono_profiler_code_transition (MonoMethod *method, int result)
272 {
273 if ((mono_profiler_events & MONO_PROFILE_TRANSITIONS) && man_unman_transition)
274 man_unman_transition (current_profiler, method, result);
275 }
276
277 void
278 mono_profiler_allocation (MonoObject *obj, MonoClass *klass)
279 {
280 if ((mono_profiler_events & MONO_PROFILE_ALLOCATIONS) && allocation_cb)
281 allocation_cb (current_profiler, obj, klass);
282 }
283
284 void
285 mono_profiler_stat_hit (guchar *ip, void *context)
286 {
287 if ((mono_profiler_events & MONO_PROFILE_STATISTICAL) && statistical_cb)
288 statistical_cb (current_profiler, ip, context);
289 }
290
291 void
292 mono_profiler_thread_start (gsize tid)
293 {
294 if ((mono_profiler_events & MONO_PROFILE_THREADS) && thread_start)
295 thread_start (current_profiler, tid);
296 }
297
298 void
299 mono_profiler_thread_end (gsize tid)
300 {
301 if ((mono_profiler_events & MONO_PROFILE_THREADS) && thread_end)
302 thread_end (current_profiler, tid);
303 }
304
305 void
306 mono_profiler_assembly_event (MonoAssembly *assembly, int code)
307 {
308 if (!(mono_profiler_events & MONO_PROFILE_ASSEMBLY_EVENTS))
309 return;
310
311 switch (code) {
312 case MONO_PROFILE_START_LOAD:
313 if (assembly_start_load)
314 assembly_start_load (current_profiler, assembly);
315 break;
316 case MONO_PROFILE_START_UNLOAD:
317 if (assembly_start_unload)
318 assembly_start_unload (current_profiler, assembly);
319 break;
320 case MONO_PROFILE_END_UNLOAD:
321 if (assembly_end_unload)
322 assembly_end_unload (current_profiler, assembly);
323 break;
324 default:
325 g_assert_not_reached ();
326 }
327 }
328
329 void
330 mono_profiler_assembly_loaded (MonoAssembly *assembly, int result)
331 {
332 if ((mono_profiler_events & MONO_PROFILE_ASSEMBLY_EVENTS) && assembly_end_load)
333 assembly_end_load (current_profiler, assembly, result);
334 }
335
336 void
337 mono_profiler_module_event (MonoImage *module, int code)
338 {
339 if (!(mono_profiler_events & MONO_PROFILE_MODULE_EVENTS))
340 return;
341
342 switch (code) {
343 case MONO_PROFILE_START_LOAD:
344 if (module_start_load)
345 module_start_load (current_profiler, module);
346 break;
347 case MONO_PROFILE_START_UNLOAD:
348 if (module_start_unload)
349 module_start_unload (current_profiler, module);
350 break;
351 case MONO_PROFILE_END_UNLOAD:
352 if (module_end_unload)
353 module_end_unload (current_profiler, module);
354 break;
355 default:
356 g_assert_not_reached ();
357 }
358 }
359
360 void
361 mono_profiler_module_loaded (MonoImage *module, int result)
362 {
363 if ((mono_profiler_events & MONO_PROFILE_MODULE_EVENTS) && module_end_load)
364 module_end_load (current_profiler, module, result);
365 }
366
367 void
368 mono_profiler_class_event (MonoClass *klass, int code)
369 {
370 if (!(mono_profiler_events & MONO_PROFILE_CLASS_EVENTS))
371 return;
372
373 switch (code) {
374 case MONO_PROFILE_START_LOAD:
375 if (class_start_load)
376 class_start_load (current_profiler, klass);
377 break;
378 case MONO_PROFILE_START_UNLOAD:
379 if (class_start_unload)
380 class_start_unload (current_profiler, klass);
381 break;
382 case MONO_PROFILE_END_UNLOAD:
383 if (class_end_unload)
384 class_end_unload (current_profiler, klass);
385 break;
386 default:
387 g_assert_not_reached ();
388 }
389 }
390
391 void
392 mono_profiler_class_loaded (MonoClass *klass, int result)
393 {
394 if ((mono_profiler_events & MONO_PROFILE_CLASS_EVENTS) && class_end_load)
395 class_end_load (current_profiler, klass, result);
396 }
397
398 void
399 mono_profiler_appdomain_event (MonoDomain *domain, int code)
400 {
401 if (!(mono_profiler_events & MONO_PROFILE_APPDOMAIN_EVENTS))
402 return;
403
404 switch (code) {
405 case MONO_PROFILE_START_LOAD:
406 if (domain_start_load)
407 domain_start_load (current_profiler, domain);
408 break;
409 case MONO_PROFILE_START_UNLOAD:
410 if (domain_start_unload)
411 domain_start_unload (current_profiler, domain);
412 break;
413 case MONO_PROFILE_END_UNLOAD:
414 if (domain_end_unload)
415 domain_end_unload (current_profiler, domain);
416 break;
417 default:
418 g_assert_not_reached ();
419 }
420 }
421
422 void
423 mono_profiler_appdomain_loaded (MonoDomain *domain, int result)
424 {
425 if ((mono_profiler_events & MONO_PROFILE_APPDOMAIN_EVENTS) && domain_end_load)
426 domain_end_load (current_profiler, domain, result);
427 }
428
429 void
430 mono_profiler_shutdown (void)
431 {
432 if (current_profiler && shutdown_callback)
433 shutdown_callback (current_profiler);
434 }
435
436 void
437 mono_profiler_gc_heap_resize (gint64 new_size)
438 {
439 if ((mono_profiler_events & MONO_PROFILE_GC) && gc_heap_resize)
440 gc_heap_resize (current_profiler, new_size);
441 }
442
443 void
444 mono_profiler_gc_event (MonoGCEvent event, int generation)
445 {
446 if ((mono_profiler_events & MONO_PROFILE_GC) && gc_event)
447 gc_event (current_profiler, event, generation);
448 }
449
450 void
451 mono_profiler_install_gc (MonoProfileGCFunc callback, MonoProfileGCResizeFunc heap_resize_callback)
452 {
453 mono_gc_enable_events ();
454 gc_event = callback;
455 gc_heap_resize = heap_resize_callback;
456 }
457
458 static GHashTable *coverage_hash = NULL;
459
460 MonoProfileCoverageInfo*
461 mono_profiler_coverage_alloc (MonoMethod *method, int entries)
462 {
463 MonoProfileCoverageInfo *res;
464
465 if (coverage_filter_cb)
466 if (! (*coverage_filter_cb) (current_profiler, method))
467 return NULL;
468
469 mono_profiler_coverage_lock ();
470 if (!coverage_hash)
471 coverage_hash = g_hash_table_new (NULL, NULL);
472
473 res = g_malloc0 (sizeof (MonoProfileCoverageInfo) + sizeof (void*) * 2 * entries);
474
475 res->entries = entries;
476
477 g_hash_table_insert (coverage_hash, method, res);
478 mono_profiler_coverage_unlock ();
479
480 return res;
481 }
482
483 /* safe only when the method antive code has been unloaded */
484 void
485 mono_profiler_coverage_free (MonoMethod *method)
486 {
487 MonoProfileCoverageInfo* info;
488
489 mono_profiler_coverage_lock ();
490 if (!coverage_hash) {
491 mono_profiler_coverage_unlock ();
492 return;
493 }
494
495 info = g_hash_table_lookup (coverage_hash, method);
496 if (info) {
497 g_free (info);
498 g_hash_table_remove (coverage_hash, method);
499 }
500 mono_profiler_coverage_unlock ();
501 }
502
503 /**
504 * mono_profiler_coverage_get:
505 * @prof: The profiler handle, installed with mono_profiler_install
506 * @method: the method to gather information from.
507 * @func: A routine that will be called back with the results
508 *
509 * If the MONO_PROFILER_INS_COVERAGE flag was active during JIT compilation
510 * it is posisble to obtain coverage information about a give method.
511 *
512 * The function @func will be invoked repeatedly with instances of the
513 * MonoProfileCoverageEntry structure.
514 */
515 void
516 mono_profiler_coverage_get (MonoProfiler *prof, MonoMethod *method, MonoProfileCoverageFunc func)
517 {
518 MonoProfileCoverageInfo* info;
519 int i, offset;
520 guint32 code_size;
521 const unsigned char *start, *end, *cil_code;
522 MonoMethodHeader *header;
523 MonoProfileCoverageEntry entry;
524 MonoDebugMethodInfo *debug_minfo;
525
526 mono_profiler_coverage_lock ();
527 info = g_hash_table_lookup (coverage_hash, method);
528 mono_profiler_coverage_unlock ();
529
530 if (!info)
531 return;
532
533 header = mono_method_get_header (method);
534 start = mono_method_header_get_code (header, &code_size, NULL);
535 debug_minfo = mono_debug_lookup_method (method);
536
537 end = start + code_size;
538 for (i = 0; i < info->entries; ++i) {
539 cil_code = info->data [i].cil_code;
540 if (cil_code && cil_code >= start && cil_code < end) {
541 char *fname = NULL;
542 offset = cil_code - start;
543 entry.iloffset = offset;
544 entry.method = method;
545 entry.counter = info->data [i].count;
546 entry.line = entry.col = 1;
547 entry.filename = NULL;
548 if (debug_minfo) {
549 MonoDebugSourceLocation *location;
550
551 location = mono_debug_symfile_lookup_location (debug_minfo, offset);
552 if (location) {
553 entry.line = location->row;
554 entry.col = location->column;
555 entry.filename = fname = g_strdup (location->source_file);
556 mono_debug_free_source_location (location);
557 }
558 }
559
560 func (prof, &entry);
561 g_free (fname);
562 }
563 }
564 }
565
566 #ifndef DISABLE_PROFILER
567 /*
568 * Small profiler extracted from mint: we should move it in a loadable module
569 * and improve it to do graphs and more accurate timestamping with rdtsc.
570 */
571
572 static FILE* poutput = NULL;
573
574 #define USE_X86TSC 0
575 #define USE_WIN32COUNTER 0
576 #if USE_X86TSC
577
578 typedef struct {
579 unsigned int lows, highs, lowe, highe;
580 } MonoRdtscTimer;
581
582 #define rdtsc(low,high) \
583 __asm__ __volatile__("rdtsc" : "=a" (low), "=d" (high))
584
585 static int freq;
586
587 static double
588 rdtsc_elapsed (MonoRdtscTimer *t)
589 {
590 unsigned long long diff;
591 unsigned int highe = t->highe;
592 if (t->lowe < t->lows)
593 highe--;
594 diff = (((unsigned long long) highe - t->highs) << 32) + (t->lowe - t->lows);
595 return ((double)diff / freq) / 1000000; /* have to return the result in seconds */
596 }
597
598 static int
599 have_rdtsc (void) {
600 char buf[256];
601 int have_freq = 0;
602 int have_flag = 0;
603 float val;
604 FILE *cpuinfo;
605
606 if (!(cpuinfo = fopen ("/proc/cpuinfo", "r")))
607 return 0;
608 while (fgets (buf, sizeof(buf), cpuinfo)) {
609 if (sscanf (buf, "cpu MHz : %f", &val) == 1) {
610 /*printf ("got mh: %f\n", val);*/
611 have_freq = val;
612 }
613 if (strncmp (buf, "flags", 5) == 0) {
614 if (strstr (buf, "tsc")) {
615 have_flag = 1;
616 /*printf ("have tsc\n");*/
617 }
618 }
619 }
620 fclose (cpuinfo);
621 return have_flag? have_freq: 0;
622 }
623
624 #define MONO_TIMER_STARTUP \
625 if (!(freq = have_rdtsc ())) g_error ("Compiled with TSC support, but none found");
626 #define MONO_TIMER_TYPE MonoRdtscTimer
627 #define MONO_TIMER_INIT(t)
628 #define MONO_TIMER_DESTROY(t)
629 #define MONO_TIMER_START(t) rdtsc ((t).lows, (t).highs);
630 #define MONO_TIMER_STOP(t) rdtsc ((t).lowe, (t).highe);
631 #define MONO_TIMER_ELAPSED(t) rdtsc_elapsed (&(t))
632
633 #elif USE_WIN32COUNTER
634 #include <windows.h>
635
636 typedef struct {
637 LARGE_INTEGER start, stop;
638 } MonoWin32Timer;
639
640 static int freq;
641
642 static double
643 win32_elapsed (MonoWin32Timer *t)
644 {
645 LONGLONG diff = t->stop.QuadPart - t->start.QuadPart;
646 return ((double)diff / freq) / 1000000; /* have to return the result in seconds */
647 }
648
649 static int
650 have_win32counter (void) {
651 LARGE_INTEGER f;
652
653 if (!QueryPerformanceFrequency (&f))
654 return 0;
655 return f.LowPart;
656 }
657
658 #define MONO_TIMER_STARTUP \
659 if (!(freq = have_win32counter ())) g_error ("Compiled with Win32 counter support, but none found");
660 #define MONO_TIMER_TYPE MonoWin32Timer
661 #define MONO_TIMER_INIT(t)
662 #define MONO_TIMER_DESTROY(t)
663 #define MONO_TIMER_START(t) QueryPerformanceCounter (&(t).start)
664 #define MONO_TIMER_STOP(t) QueryPerformanceCounter (&(t).stop)
665 #define MONO_TIMER_ELAPSED(t) win32_elapsed (&(t))
666
667 #else
668
669 typedef struct {
670 GTimeVal start, stop;
671 } MonoGLibTimer;
672
673 static double
674 timeval_elapsed (MonoGLibTimer *t)
675 {
676 if (t->start.tv_usec > t->stop.tv_usec) {
677 t->stop.tv_usec += G_USEC_PER_SEC;
678 t->stop.tv_sec--;
679 }
680 return (t->stop.tv_sec - t->start.tv_sec)
681 + ((double)(t->stop.tv_usec - t->start.tv_usec))/ G_USEC_PER_SEC;
682 }
683
684 #define MONO_TIMER_STARTUP
685 #define MONO_TIMER_TYPE MonoGLibTimer
686 #define MONO_TIMER_INIT(t)
687 #define MONO_TIMER_DESTROY(t)
688 #define MONO_TIMER_START(t) g_get_current_time (&(t).start)
689 #define MONO_TIMER_STOP(t) g_get_current_time (&(t).stop)
690 #define MONO_TIMER_ELAPSED(t) timeval_elapsed (&(t))
691 #endif
692
693 typedef struct _AllocInfo AllocInfo;
694 typedef struct _CallerInfo CallerInfo;
695 typedef struct _LastCallerInfo LastCallerInfo;
696
697 struct _MonoProfiler {
698 GHashTable *methods;
699 MonoMemPool *mempool;
700 /* info about JIT time */
701 MONO_TIMER_TYPE jit_timer;
702 double jit_time;
703 double max_jit_time;
704 MonoMethod *max_jit_method;
705 int methods_jitted;
706
707 GSList *per_thread;
708
709 /* chain of callers for the current thread */
710 LastCallerInfo *callers;
711 /* LastCallerInfo nodes for faster allocation */
712 LastCallerInfo *cstorage;
713 };
714
715 typedef struct {
716 MonoMethod *method;
717 guint64 count;
718 double total;
719 AllocInfo *alloc_info;
720 CallerInfo *caller_info;
721 } MethodProfile;
722
723 typedef struct _MethodCallProfile MethodCallProfile;
724
725 struct _MethodCallProfile {
726 MethodCallProfile *next;
727 MONO_TIMER_TYPE timer;
728 MonoMethod *method;
729 };
730
731 struct _AllocInfo {
732 AllocInfo *next;
733 MonoClass *klass;
734 guint64 count;
735 guint64 mem;
736 };
737
738 struct _CallerInfo {
739 CallerInfo *next;
740 MonoMethod *caller;
741 guint count;
742 };
743
744 struct _LastCallerInfo {
745 LastCallerInfo *next;
746 MonoMethod *method;
747 MONO_TIMER_TYPE timer;
748 };
749
750 static MonoProfiler*
751 create_profiler (void)
752 {
753 MonoProfiler *prof = g_new0 (MonoProfiler, 1);
754
755 prof->methods = g_hash_table_new (mono_aligned_addr_hash, NULL);
756 MONO_TIMER_INIT (prof->jit_timer);
757 prof->mempool = mono_mempool_new ();
758 return prof;
759 }
760 #if 1
761
762 #ifdef HAVE_KW_THREAD
763 static __thread MonoProfiler * tls_profiler;
764 # define GET_PROFILER() tls_profiler
765 # define SET_PROFILER(x) tls_profiler = (x)
766 # define ALLOC_PROFILER() /* nop */
767 #else
768 static guint32 profiler_thread_id = -1;
769 # define GET_PROFILER() ((MonoProfiler *)TlsGetValue (profiler_thread_id))
770 # define SET_PROFILER(x) TlsSetValue (profiler_thread_id, x);
771 # define ALLOC_PROFILER() profiler_thread_id = TlsAlloc ()
772 #endif
773
774 #define GET_THREAD_PROF(prof) do { \
775 MonoProfiler *_tprofiler = GET_PROFILER (); \
776 if (!_tprofiler) { \
777 _tprofiler = create_profiler (); \
778 prof->per_thread = g_slist_prepend (prof->per_thread, _tprofiler); \
779 SET_PROFILER (_tprofiler); \
780 } \
781 prof = _tprofiler; \
782 } while (0)
783 #else
784 /* thread unsafe but faster variant */
785 #define GET_THREAD_PROF(prof)
786 #endif
787
788 static gint
789 compare_profile (MethodProfile *profa, MethodProfile *profb)
790 {
791 return (gint)((profb->total - profa->total)*1000);
792 }
793
794 static void
795 build_profile (MonoMethod *m, MethodProfile *prof, GList **funcs)
796 {
797 prof->method = m;
798 *funcs = g_list_insert_sorted (*funcs, prof, (GCompareFunc)compare_profile);
799 }
800
801 static char*
802 method_get_name (MonoMethod* method)
803 {
804 char *sig, *res;
805
806 sig = mono_signature_get_desc (mono_method_signature (method), FALSE);
807 res = g_strdup_printf ("%s%s%s::%s(%s)", method->klass->name_space,
808 method->klass->name_space ? "." : "", method->klass->name,
809 method->name, sig);
810 g_free (sig);
811 return res;
812 }
813
814 static void output_callers (MethodProfile *p);
815
816 /* This isn't defined on older glib versions and on some platforms */
817 #ifndef G_GUINT64_FORMAT
818 #define G_GUINT64_FORMAT "ul"
819 #endif
820 #ifndef G_GINT64_FORMAT
821 #define G_GINT64_FORMAT "lld"
822 #endif
823
824 static void
825 output_profile (GList *funcs)
826 {
827 GList *tmp;
828 MethodProfile *p;
829 char *m;
830 guint64 total_calls = 0;
831
832 if (funcs)
833 fprintf (poutput, "Time(ms) Count P/call(ms) Method name\n");
834 for (tmp = funcs; tmp; tmp = tmp->next) {
835 p = tmp->data;
836 total_calls += p->count;
837 if (!(gint)(p->total*1000))
838 continue;
839 m = method_get_name (p->method);
840 fprintf (poutput, "########################\n");
841 fprintf (poutput, "% 8.3f ", (double) (p->total * 1000));
842 fprintf (poutput, "%7" G_GUINT64_FORMAT " ", (unsigned long long)p->count);
843 fprintf (poutput, "% 8.3f ", (double) (p->total * 1000)/(double)p->count);
844 fprintf (poutput, " %s\n", m);
845
846 g_free (m);
847 /* callers */
848 output_callers (p);
849 }
850 fprintf (poutput, "Total number of calls: %" G_GINT64_FORMAT "\n", (long long)total_calls);
851 }
852
853 typedef struct {
854 MethodProfile *mp;
855 guint64 count;
856 } NewobjProfile;
857
858 static gint
859 compare_newobj_profile (NewobjProfile *profa, NewobjProfile *profb)
860 {
861 if (profb->count == profa->count)
862 return 0;
863 else
864 return profb->count > profa->count ? 1 : -1;
865 }
866
867 static void
868 build_newobj_profile (MonoClass *class, MethodProfile *mprof, GList **funcs)
869 {
870 NewobjProfile *prof = g_new (NewobjProfile, 1);
871 AllocInfo *tmp;
872 guint64 count = 0;
873
874 prof->mp = mprof;
875 /* we use the total amount of memory to sort */
876 for (tmp = mprof->alloc_info; tmp; tmp = tmp->next)
877 count += tmp->mem;
878 prof->count = count;
879 *funcs = g_list_insert_sorted (*funcs, prof, (GCompareFunc)compare_newobj_profile);
880 }
881
882 static int
883 compare_caller (CallerInfo *a, CallerInfo *b)
884 {
885 return b->count - a->count;
886 }
887
888 static int
889 compare_alloc (AllocInfo *a, AllocInfo *b)
890 {
891 return b->mem - a->mem;
892 }
893
894 static GSList*
895 sort_alloc_list (AllocInfo *ai)
896 {
897 GSList *l = NULL;
898 AllocInfo *tmp;
899 for (tmp = ai; tmp; tmp = tmp->next) {
900 l = g_slist_insert_sorted (l, tmp, (GCompareFunc)compare_alloc);
901 }
902 return l;
903 }
904
905 static GSList*
906 sort_caller_list (CallerInfo *ai)
907 {
908 GSList *l = NULL;
909 CallerInfo *tmp;
910 for (tmp = ai; tmp; tmp = tmp->next) {
911 l = g_slist_insert_sorted (l, tmp, (GCompareFunc)compare_caller);
912 }
913 return l;
914 }
915
916 static void
917 output_callers (MethodProfile *p) {
918 guint total_callers, percent;
919 GSList *sorted, *tmps;
920 CallerInfo *cinfo;
921 char *m;
922
923 fprintf (poutput, " Callers (with count) that contribute at least for 1%%:\n");
924 total_callers = 0;
925 for (cinfo = p->caller_info; cinfo; cinfo = cinfo->next) {
926 total_callers += cinfo->count;
927 }
928 sorted = sort_caller_list (p->caller_info);
929 for (tmps = sorted; tmps; tmps = tmps->next) {
930 cinfo = tmps->data;
931 percent = (cinfo->count * 100)/total_callers;
932 if (percent < 1)
933 continue;
934 m = method_get_name (cinfo->caller);
935 fprintf (poutput, " %8d % 3d %% %s\n", cinfo->count, percent, m);
936 g_free (m);
937 }
938 }
939
940 static void
941 output_newobj_profile (GList *proflist)
942 {
943 GList *tmp;
944 NewobjProfile *p;
945 MethodProfile *mp;
946 AllocInfo *ainfo;
947 MonoClass *klass;
948 const char* isarray;
949 char buf [256];
950 char *m;
951 guint64 total = 0;
952 GSList *sorted, *tmps;
953
954 fprintf (poutput, "\nAllocation profiler\n");
955
956 if (proflist)
957 fprintf (poutput, "%-9s %s\n", "Total mem", "Method");
958 for (tmp = proflist; tmp; tmp = tmp->next) {
959 p = tmp->data;
960 total += p->count;
961 if (p->count < 50000)
962 continue;
963 mp = p->mp;
964 m = method_get_name (mp->method);
965 fprintf (poutput, "########################\n%8" G_GUINT64_FORMAT " KB %s\n", (p->count / 1024), m);
966 g_free (m);
967 sorted = sort_alloc_list (mp->alloc_info);
968 for (tmps = sorted; tmps; tmps = tmps->next) {
969 ainfo = tmps->data;
970 if (ainfo->mem < 50000)
971 continue;
972 klass = ainfo->klass;
973 if (klass->rank) {
974 isarray = "[]";
975 klass = klass->element_class;
976 } else {
977 isarray = "";
978 }
979 g_snprintf (buf, sizeof (buf), "%s%s%s%s",
980 klass->name_space, klass->name_space ? "." : "", klass->name, isarray);
981 fprintf (poutput, " %8" G_GUINT64_FORMAT " KB %8" G_GUINT64_FORMAT " %-48s\n", (ainfo->mem / 1024), ainfo->count, buf);
982 }
983 /* callers */
984 output_callers (mp);
985 }
986 fprintf (poutput, "Total memory allocated: %" G_GUINT64_FORMAT " KB\n", total / 1024);
987 }
988
989 static void
990 merge_methods (MonoMethod *method, MethodProfile *profile, MonoProfiler *prof)
991 {
992 MethodProfile *mprof;
993 AllocInfo *talloc_info, *alloc_info;
994 CallerInfo *tcaller_info, *caller_info;
995
996 mprof = g_hash_table_lookup (prof->methods, method);
997 if (!mprof) {
998 /* the master thread didn't see this method, just transfer the info as is */
999 g_hash_table_insert (prof->methods, method, profile);
1000 return;
1001 }
1002 /* merge the info from profile into mprof */
1003 mprof->count += profile->count;
1004 mprof->total += profile->total;
1005 /* merge alloc info */
1006 for (talloc_info = profile->alloc_info; talloc_info; talloc_info = talloc_info->next) {
1007 for (alloc_info = mprof->alloc_info; alloc_info; alloc_info = alloc_info->next) {
1008 if (alloc_info->klass == talloc_info->klass) {
1009 /* mprof already has a record for the klass, merge */
1010 alloc_info->count += talloc_info->count;
1011 alloc_info->mem += talloc_info->mem;
1012 break;
1013 }
1014 }
1015 if (!alloc_info) {
1016 /* mprof didn't have the info, just copy it over */
1017 alloc_info = mono_mempool_alloc0 (prof->mempool, sizeof (AllocInfo));
1018 *alloc_info = *talloc_info;
1019 alloc_info->next = mprof->alloc_info;
1020 mprof->alloc_info = alloc_info->next;
1021 }
1022 }
1023 /* merge callers info */
1024 for (tcaller_info = profile->caller_info; tcaller_info; tcaller_info = tcaller_info->next) {
1025 for (caller_info = mprof->caller_info; caller_info; caller_info = caller_info->next) {
1026 if (caller_info->caller == tcaller_info->caller) {
1027 /* mprof already has a record for the caller method, merge */
1028 caller_info->count += tcaller_info->count;
1029 break;
1030 }
1031 }
1032 if (!caller_info) {
1033 /* mprof didn't have the info, just copy it over */
1034 caller_info = mono_mempool_alloc0 (prof->mempool, sizeof (CallerInfo));
1035 *caller_info = *tcaller_info;
1036 caller_info->next = mprof->caller_info;
1037 mprof->caller_info = caller_info;
1038 }
1039 }
1040 }
1041
1042 static void
1043 merge_thread_data (MonoProfiler *master, MonoProfiler *tprof)
1044 {
1045 master->jit_time += tprof->jit_time;
1046 master->methods_jitted += tprof->methods_jitted;
1047 if (master->max_jit_time < tprof->max_jit_time) {
1048 master->max_jit_time = tprof->max_jit_time;
1049 master->max_jit_method = tprof->max_jit_method;
1050 }
1051
1052 g_hash_table_foreach (tprof->methods, (GHFunc)merge_methods, master);
1053 }
1054
1055 static void
1056 simple_method_enter (MonoProfiler *prof, MonoMethod *method)
1057 {
1058 MethodProfile *profile_info;
1059 LastCallerInfo *callinfo;
1060 GET_THREAD_PROF (prof);
1061 /*g_print ("enter %p %s::%s in %d (%p)\n", method, method->klass->name, method->name, GetCurrentThreadId (), prof);*/
1062 if (!(profile_info = g_hash_table_lookup (prof->methods, method))) {
1063 profile_info = mono_mempool_alloc0 (prof->mempool, sizeof (MethodProfile));
1064 MONO_TIMER_INIT (profile_info->u.timer);
1065 g_hash_table_insert (prof->methods, method, profile_info);
1066 }
1067 profile_info->count++;
1068 if (prof->callers) {
1069 CallerInfo *cinfo;
1070 MonoMethod *caller = prof->callers->method;
1071 for (cinfo = profile_info->caller_info; cinfo; cinfo = cinfo->next) {
1072 if (cinfo->caller == caller)
1073 break;
1074 }
1075 if (!cinfo) {
1076 cinfo = mono_mempool_alloc0 (prof->mempool, sizeof (CallerInfo));
1077 cinfo->caller = caller;
1078 cinfo->next = profile_info->caller_info;
1079 profile_info->caller_info = cinfo;
1080 }
1081 cinfo->count++;
1082 }
1083 if (!(callinfo = prof->cstorage)) {
1084 callinfo = mono_mempool_alloc (prof->mempool, sizeof (LastCallerInfo));
1085 MONO_TIMER_INIT (callinfo->timer);
1086 } else {
1087 prof->cstorage = prof->cstorage->next;
1088 }
1089 callinfo->method = method;
1090 callinfo->next = prof->callers;
1091 prof->callers = callinfo;
1092 MONO_TIMER_START (callinfo->timer);
1093 }
1094
1095 static void
1096 simple_method_leave (MonoProfiler *prof, MonoMethod *method)
1097 {
1098 MethodProfile *profile_info;
1099 LastCallerInfo *callinfo, *newcallinfo = NULL;
1100
1101 GET_THREAD_PROF (prof);
1102 /*g_print ("leave %p %s::%s in %d (%p)\n", method, method->klass->name, method->name, GetCurrentThreadId (), prof);*/
1103 callinfo = prof->callers;
1104 /* should really not happen, but we don't catch exceptions events, yet ... */
1105 while (callinfo) {
1106 MONO_TIMER_STOP (callinfo->timer);
1107 profile_info = g_hash_table_lookup (prof->methods, callinfo->method);
1108 if (profile_info)
1109 profile_info->total += MONO_TIMER_ELAPSED (callinfo->timer);
1110 newcallinfo = callinfo->next;
1111 callinfo->next = prof->cstorage;
1112 prof->cstorage = callinfo;
1113 if (callinfo->method == method)
1114 break;
1115 callinfo = newcallinfo;
1116 }
1117 prof->callers = newcallinfo;
1118 }
1119
1120 static void
1121 simple_allocation (MonoProfiler *prof, MonoObject *obj, MonoClass *klass)
1122 {
1123 MethodProfile *profile_info;
1124 AllocInfo *tmp;
1125
1126 GET_THREAD_PROF (prof);
1127 if (prof->callers) {
1128 MonoMethod *caller = prof->callers->method;
1129
1130 /* Otherwise all allocations are attributed to icall_wrapper_mono_object_new */
1131 if (caller->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE)
1132 caller = prof->callers->next->method;
1133
1134 if (!(profile_info = g_hash_table_lookup (prof->methods, caller)))
1135 g_assert_not_reached ();
1136 } else {
1137 return; /* fine for now */
1138 }
1139
1140 for (tmp = profile_info->alloc_info; tmp; tmp = tmp->next) {
1141 if (tmp->klass == klass)
1142 break;
1143 }
1144 if (!tmp) {
1145 tmp = mono_mempool_alloc0 (prof->mempool, sizeof (AllocInfo));
1146 tmp->klass = klass;
1147 tmp->next = profile_info->alloc_info;
1148 profile_info->alloc_info = tmp;
1149 }
1150 tmp->count++;
1151 tmp->mem += mono_object_get_size (obj);
1152 }
1153
1154 static void
1155 simple_method_jit (MonoProfiler *prof, MonoMethod *method)
1156 {
1157 GET_THREAD_PROF (prof);
1158 prof->methods_jitted++;
1159 MONO_TIMER_START (prof->jit_timer);
1160 }
1161
1162 static void
1163 simple_method_end_jit (MonoProfiler *prof, MonoMethod *method, int result)
1164 {
1165 double jtime;
1166 GET_THREAD_PROF (prof);
1167 MONO_TIMER_STOP (prof->jit_timer);
1168 jtime = MONO_TIMER_ELAPSED (prof->jit_timer);
1169 prof->jit_time += jtime;
1170 if (jtime > prof->max_jit_time) {
1171 prof->max_jit_time = jtime;
1172 prof->max_jit_method = method;
1173 }
1174 }
1175
1176 /* about 10 minutes of samples */
1177 #define MAX_PROF_SAMPLES (1000*60*10)
1178 static int prof_counts = 0;
1179 static int prof_ucounts = 0;
1180 static gpointer* prof_addresses = NULL;
1181 static GHashTable *prof_table = NULL;
1182
1183 static void
1184 simple_stat_hit (MonoProfiler *prof, guchar *ip, void *context)
1185 {
1186 int pos;
1187
1188 if (prof_counts >= MAX_PROF_SAMPLES)
1189 return;
1190 pos = InterlockedIncrement (&prof_counts);
1191 prof_addresses [pos - 1] = ip;
1192 }
1193
1194 static int
1195 compare_methods_prof (gconstpointer a, gconstpointer b)
1196 {
1197 int ca = GPOINTER_TO_UINT (g_hash_table_lookup (prof_table, a));
1198 int cb = GPOINTER_TO_UINT (g_hash_table_lookup (prof_table, b));
1199 return cb-ca;
1200 }
1201
1202 static void
1203 prof_foreach (char *method, gpointer c, gpointer data)
1204 {
1205 GList **list = data;
1206 *list = g_list_insert_sorted (*list, method, compare_methods_prof);
1207 }
1208
1209 typedef struct Addr2LineData Addr2LineData;
1210
1211 struct Addr2LineData {
1212 Addr2LineData *next;
1213 FILE *pipein;
1214 FILE *pipeout;
1215 char *binary;
1216 int child_pid;
1217 };
1218
1219 static Addr2LineData *addr2line_pipes = NULL;
1220
1221 static char*
1222 try_addr2line (const char* binary, gpointer ip)
1223 {
1224 char buf [1024];
1225 char *res;
1226 Addr2LineData *addr2line;
1227
1228 for (addr2line = addr2line_pipes; addr2line; addr2line = addr2line->next) {
1229 if (strcmp (binary, addr2line->binary) == 0)
1230 break;
1231 }
1232 if (!addr2line) {
1233 const char *addr_argv[] = {"addr2line", "-f", "-e", binary, NULL};
1234 int child_pid;
1235 int ch_in, ch_out;
1236 #ifdef __linux__
1237 char monobin [1024];
1238 /* non-linux platforms will need different code here */
1239 if (strcmp (binary, "mono") == 0) {
1240 int count = readlink ("/proc/self/exe", monobin, sizeof (monobin));
1241 if (count >= 0 && count < sizeof (monobin)) {
1242 monobin [count] = 0;
1243 addr_argv [3] = monobin;
1244 }
1245 }
1246 #endif
1247 if (!g_spawn_async_with_pipes (NULL, (char**)addr_argv, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL,
1248 &child_pid, &ch_in, &ch_out, NULL, NULL)) {
1249 return g_strdup (binary);
1250 }
1251 addr2line = g_new0 (Addr2LineData, 1);
1252 addr2line->child_pid = child_pid;
1253 addr2line->binary = g_strdup (binary);
1254 addr2line->pipein = fdopen (ch_in, "w");
1255 addr2line->pipeout = fdopen (ch_out, "r");
1256 addr2line->next = addr2line_pipes;
1257 addr2line_pipes = addr2line;
1258 }
1259 fprintf (addr2line->pipein, "%p\n", ip);
1260 fflush (addr2line->pipein);
1261 /* we first get the func name and then file:lineno in a second line */
1262 if (fgets (buf, sizeof (buf), addr2line->pipeout) && buf [0] != '?') {
1263 char *end = strchr (buf, '\n');
1264 if (end)
1265 *end = 0;
1266 res = g_strdup_printf ("%s(%s", binary, buf);
1267 /* discard the filename/line info */
1268 fgets (buf, sizeof (buf), addr2line->pipeout);
1269 } else {
1270 res = g_strdup (binary);
1271 }
1272 return res;
1273 }
1274
1275 static void
1276 stat_prof_report (void)
1277 {
1278 MonoJitInfo *ji;
1279 int count = prof_counts;
1280 int i, c;
1281 char *mn;
1282 gpointer ip;
1283 GList *tmp, *sorted = NULL;
1284 int pcount = ++ prof_counts;
1285
1286 prof_counts = MAX_PROF_SAMPLES;
1287 for (i = 0; i < count; ++i) {
1288 ip = prof_addresses [i];
1289 ji = mono_jit_info_table_find (mono_domain_get (), ip);
1290 if (ji) {
1291 mn = mono_method_full_name (ji->method, TRUE);
1292 } else {
1293 #ifdef HAVE_BACKTRACE_SYMBOLS
1294 char **names;
1295 char *send;
1296 int no_func;
1297 prof_ucounts++;
1298 names = backtrace_symbols (&ip, 1);
1299 send = strchr (names [0], '+');
1300 if (send) {
1301 *send = 0;
1302 no_func = 0;
1303 } else {
1304 no_func = 1;
1305 }
1306 send = strchr (names [0], '[');
1307 if (send)
1308 *send = 0;
1309 if (no_func && names [0][0]) {
1310 char *endp = strchr (names [0], 0);
1311 while (--endp >= names [0] && g_ascii_isspace (*endp))
1312 *endp = 0;
1313 mn = try_addr2line (names [0], ip);
1314 } else {
1315 mn = g_strdup (names [0]);
1316 }
1317 free (names);
1318 #else
1319 prof_ucounts++;
1320 mn = g_strdup_printf ("unmanaged [%p]", ip);
1321 #endif
1322 }
1323 c = GPOINTER_TO_UINT (g_hash_table_lookup (prof_table, mn));
1324 c++;
1325 g_hash_table_insert (prof_table, mn, GUINT_TO_POINTER (c));
1326 if (c > 1)
1327 g_free (mn);
1328 }
1329 fprintf (poutput, "prof counts: total/unmanaged: %d/%d\n", pcount, prof_ucounts);
1330 g_hash_table_foreach (prof_table, (GHFunc)prof_foreach, &sorted);
1331 for (tmp = sorted; tmp; tmp = tmp->next) {
1332 double perc;
1333 c = GPOINTER_TO_UINT (g_hash_table_lookup (prof_table, tmp->data));
1334 perc = c*100.0/count;
1335 fprintf (poutput, "%7d\t%5.2f %% %s\n", c, perc, (char*)tmp->data);
1336 }
1337 g_list_free (sorted);
1338 }
1339
1340 static void
1341 simple_appdomain_unload (MonoProfiler *prof, MonoDomain *domain)
1342 {
1343 /* FIXME: we should actually record partial data for each domain,
1344 * since the ip->ji->method mappings are going away at domain unload time.
1345 */
1346 if (domain == mono_get_root_domain ())
1347 stat_prof_report ();
1348 }
1349
1350 static void
1351 simple_shutdown (MonoProfiler *prof)
1352 {
1353 GList *profile = NULL;
1354 MonoProfiler *tprof;
1355 GSList *tmp;
1356 char *str;
1357
1358 for (tmp = prof->per_thread; tmp; tmp = tmp->next) {
1359 tprof = tmp->data;
1360 merge_thread_data (prof, tprof);
1361 }
1362
1363 fprintf (poutput, "Total time spent compiling %d methods (sec): %.4g\n", prof->methods_jitted, prof->jit_time);
1364 if (prof->max_jit_method) {
1365 str = method_get_name (prof->max_jit_method);
1366 fprintf (poutput, "Slowest method to compile (sec): %.4g: %s\n", prof->max_jit_time, str);
1367 g_free (str);
1368 }
1369 g_hash_table_foreach (prof->methods, (GHFunc)build_profile, &profile);
1370 output_profile (profile);
1371 g_list_free (profile);
1372 profile = NULL;
1373
1374 g_hash_table_foreach (prof->methods, (GHFunc)build_newobj_profile, &profile);
1375 output_newobj_profile (profile);
1376 g_list_free (profile);
1377
1378 g_free (prof_addresses);
1379 prof_addresses = NULL;
1380 g_hash_table_destroy (prof_table);
1381 }
1382
1383 static void
1384 mono_profiler_install_simple (const char *desc)
1385 {
1386 MonoProfiler *prof;
1387 gchar **args, **ptr;
1388 MonoProfileFlags flags = 0;
1389
1390 MONO_TIMER_STARTUP;
1391 poutput = stdout;
1392
1393 if (!desc)
1394 desc = "alloc,time,jit";
1395
1396 if (desc) {
1397 /* Parse options */
1398 if (strstr (desc, ":"))
1399 desc = strstr (desc, ":") + 1;
1400 else
1401 desc = "alloc,time,jit";
1402 args = g_strsplit (desc, ",", -1);
1403
1404 for (ptr = args; ptr && *ptr; ptr++) {
1405 const char *arg = *ptr;
1406
1407 if (!strcmp (arg, "time"))
1408 flags |= MONO_PROFILE_ENTER_LEAVE;
1409 else if (!strcmp (arg, "alloc"))
1410 flags |= MONO_PROFILE_ALLOCATIONS;
1411 else if (!strcmp (arg, "stat"))
1412 flags |= MONO_PROFILE_STATISTICAL | MONO_PROFILE_APPDOMAIN_EVENTS;
1413 else if (!strcmp (arg, "jit"))
1414 flags |= MONO_PROFILE_JIT_COMPILATION;
1415 else if (strncmp (arg, "file=", 5) == 0) {
1416 poutput = fopen (arg + 5, "wb");
1417 if (!poutput) {
1418 poutput = stdout;
1419 fprintf (stderr, "profiler : cannot open profile output file '%s'.\n", arg + 5);
1420 }
1421 } else {
1422 fprintf (stderr, "profiler : Unknown argument '%s'.\n", arg);
1423 return;
1424 }
1425 }
1426 }
1427 if (flags & MONO_PROFILE_ALLOCATIONS)
1428 flags |= MONO_PROFILE_ENTER_LEAVE;
1429 if (!flags)
1430 flags = MONO_PROFILE_ENTER_LEAVE | MONO_PROFILE_ALLOCATIONS | MONO_PROFILE_JIT_COMPILATION;
1431
1432 prof = create_profiler ();
1433 ALLOC_PROFILER ();
1434 SET_PROFILER (prof);
1435
1436 /* statistical profiler data */
1437 prof_addresses = g_new0 (gpointer, MAX_PROF_SAMPLES);
1438 prof_table = g_hash_table_new (g_str_hash, g_str_equal);
1439
1440 mono_profiler_install (prof, simple_shutdown);
1441 mono_profiler_install_enter_leave (simple_method_enter, simple_method_leave);
1442 mono_profiler_install_jit_compile (simple_method_jit, simple_method_end_jit);
1443 mono_profiler_install_allocation (simple_allocation);
1444 mono_profiler_install_appdomain (NULL, NULL, simple_appdomain_unload, NULL);
1445 mono_profiler_install_statistical (simple_stat_hit);
1446 mono_profiler_set_events (flags);
1447 }
1448
1449 #endif /* DISABLE_PROFILER */
1450
1451 typedef void (*ProfilerInitializer) (const char*);
1452 #define INITIALIZER_NAME "mono_profiler_startup"
1453
1454 /**
1455 * mono_profiler_load:
1456 * @desc: arguments to configure the profiler
1457 *
1458 * Invoke this method to initialize the profiler. This will drive the
1459 * loading of the internal ("default") or any external profilers.
1460 *
1461 * This routine is invoked by Mono's driver, but must be called manually
1462 * if you embed Mono into your application.
1463 */
1464 void
1465 mono_profiler_load (const char *desc)
1466 {
1467 #ifndef DISABLE_PROFILER
1468 if (!desc || (strcmp ("default", desc) == 0) || (strncmp (desc, "default:", 8) == 0)) {
1469 mono_profiler_install_simple (desc);
1470 return;
1471 }
1472 #else
1473 if (!desc) {
1474 desc = "default";
1475 }
1476 #endif
1477 {
1478 MonoDl *pmodule;
1479 const char* col = strchr (desc, ':');
1480 char* libname;
1481 char* path;
1482 char *mname;
1483 char *err;
1484 void *iter;
1485 if (col != NULL) {
1486 mname = g_memdup (desc, col - desc);
1487 mname [col - desc] = 0;
1488 } else {
1489 mname = g_strdup (desc);
1490 }
1491 libname = g_strdup_printf ("mono-profiler-%s", mname);
1492 iter = NULL;
1493 err = NULL;
1494 while ((path = mono_dl_build_path (NULL, libname, &iter))) {
1495 g_free (err);
1496 pmodule = mono_dl_open (path, MONO_DL_LAZY, &err);
1497 if (pmodule) {
1498 ProfilerInitializer func;
1499 if ((err = mono_dl_symbol (pmodule, INITIALIZER_NAME, (gpointer *)&func))) {
1500 g_warning ("Cannot find initializer function %s in profiler module: %s (%s)", INITIALIZER_NAME, libname, err);
1501 g_free (err);
1502 err = NULL;
1503 } else {
1504 func (desc);
1505 }
1506 break;
1507 }
1508 g_free (path);
1509 }
1510 if (!pmodule) {
1511 g_warning ("Error loading profiler module '%s': %s", libname, err);
1512 g_free (err);
1513 }
1514 g_free (libname);
1515 g_free (mname);
1516 g_free (path);
1517 }
1518 }
1519
git-svn mirror of mono