* Author:
* Paolo Molaro (lupus@ximian.com)
*
- * (C) 2001-2003 Ximian, Inc.
- * (C) 2003-2006 Novell, Inc.
+ * Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
+ * Copyright 2004-2009 Novell, Inc (http://www.novell.com)
*/
#include "config.h"
#include "mono/metadata/profiler-private.h"
#include "mono/metadata/debug-helpers.h"
#include "mono/metadata/mono-debug.h"
+#include "mono/metadata/debug-mono-symfile.h"
#include "mono/metadata/metadata-internals.h"
#include "mono/metadata/class-internals.h"
#include "mono/metadata/domain-internals.h"
#include "mono/metadata/gc-internal.h"
#include "mono/io-layer/io-layer.h"
+#include "mono/utils/mono-dl.h"
#include <string.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
-#include <gmodule.h>
+#endif
#ifdef HAVE_BACKTRACE_SYMBOLS
#include <execinfo.h>
#endif
static MonoProfileMethodFunc jit_start;
static MonoProfileMethodResult jit_end;
static MonoProfileJitResult jit_end2;
+static MonoProfileMethodFunc method_free;
static MonoProfileMethodResult man_unman_transition;
static MonoProfileAllocFunc allocation_cb;
static MonoProfileStatFunc statistical_cb;
+static MonoProfileStatCallChainFunc statistical_call_chain_cb;
+static int statistical_call_chain_depth;
static MonoProfileMethodFunc method_enter;
static MonoProfileMethodFunc method_leave;
+static MonoProfileExceptionFunc exception_throw_cb;
+static MonoProfileMethodFunc exception_method_leave_cb;
+static MonoProfileExceptionClauseFunc exception_clause_cb;
+
static MonoProfileThreadFunc thread_start;
static MonoProfileThreadFunc thread_end;
static MonoProfileGCFunc gc_event;
static MonoProfileGCResizeFunc gc_heap_resize;
+static MonoProfileFunc runtime_initialized_event;
+
#define mono_profiler_coverage_lock() EnterCriticalSection (&profiler_coverage_mutex)
#define mono_profiler_coverage_unlock() LeaveCriticalSection (&profiler_coverage_mutex)
static CRITICAL_SECTION profiler_coverage_mutex;
jit_end2 = end;
}
+void
+mono_profiler_install_method_free (MonoProfileMethodFunc callback)
+{
+ method_free = callback;
+}
+
void
mono_profiler_install_thread (MonoProfileThreadFunc start, MonoProfileThreadFunc end)
{
statistical_cb = callback;
}
+void
+mono_profiler_install_statistical_call_chain (MonoProfileStatCallChainFunc callback, int call_chain_depth) {
+ statistical_call_chain_cb = callback;
+ statistical_call_chain_depth = call_chain_depth;
+ if (statistical_call_chain_depth > MONO_PROFILER_MAX_STAT_CALL_CHAIN_DEPTH) {
+ statistical_call_chain_depth = MONO_PROFILER_MAX_STAT_CALL_CHAIN_DEPTH;
+ }
+}
+
+int
+mono_profiler_stat_get_call_chain_depth (void) {
+ if (statistical_call_chain_cb != NULL) {
+ return statistical_call_chain_depth;
+ } else {
+ return 0;
+ }
+}
+
+void mono_profiler_install_exception (MonoProfileExceptionFunc throw_callback, MonoProfileMethodFunc exc_method_leave, MonoProfileExceptionClauseFunc clause_callback)
+{
+ exception_throw_cb = throw_callback;
+ exception_method_leave_cb = exc_method_leave;
+ exception_clause_cb = clause_callback;
+}
+
void
mono_profiler_install_coverage_filter (MonoProfileCoverageFilterFunc callback)
{
}
}
+void
+mono_profiler_method_free (MonoMethod *method)
+{
+ if ((mono_profiler_events & MONO_PROFILE_METHOD_EVENTS) && method_free)
+ method_free (current_profiler, method);
+}
+
void
mono_profiler_code_transition (MonoMethod *method, int result)
{
statistical_cb (current_profiler, ip, context);
}
+void
+mono_profiler_stat_call_chain (int call_chain_depth, guchar **ips, void *context)
+{
+ if ((mono_profiler_events & MONO_PROFILE_STATISTICAL) && statistical_call_chain_cb)
+ statistical_call_chain_cb (current_profiler, call_chain_depth, ips, context);
+}
+
+void
+mono_profiler_exception_thrown (MonoObject *exception)
+{
+ if ((mono_profiler_events & MONO_PROFILE_EXCEPTIONS) && exception_throw_cb)
+ exception_throw_cb (current_profiler, exception);
+}
+
+void
+mono_profiler_exception_method_leave (MonoMethod *method)
+{
+ if ((mono_profiler_events & MONO_PROFILE_EXCEPTIONS) && exception_method_leave_cb)
+ exception_method_leave_cb (current_profiler, method);
+}
+
+void
+mono_profiler_exception_clause_handler (MonoMethod *method, int clause_type, int clause_num)
+{
+ if ((mono_profiler_events & MONO_PROFILE_EXCEPTIONS) && exception_clause_cb)
+ exception_clause_cb (current_profiler, method, clause_type, clause_num);
+}
+
void
mono_profiler_thread_start (gsize tid)
{
gc_heap_resize = heap_resize_callback;
}
+void
+mono_profiler_install_runtime_initialized (MonoProfileFunc runtime_initialized_callback)
+{
+ runtime_initialized_event = runtime_initialized_callback;
+}
+
+void
+mono_profiler_runtime_initialized (void) {
+ if (runtime_initialized_event)
+ runtime_initialized_event (current_profiler);
+}
+
+
static GHashTable *coverage_hash = NULL;
MonoProfileCoverageInfo*
{
MonoProfileCoverageInfo* info;
int i, offset;
- guint32 line, col;
+ guint32 code_size;
const unsigned char *start, *end, *cil_code;
MonoMethodHeader *header;
MonoProfileCoverageEntry entry;
+ MonoDebugMethodInfo *debug_minfo;
mono_profiler_coverage_lock ();
info = g_hash_table_lookup (coverage_hash, method);
return;
header = mono_method_get_header (method);
- start = mono_method_header_get_code (header, &col, NULL);
- end = start + col;
+ start = mono_method_header_get_code (header, &code_size, NULL);
+ debug_minfo = mono_debug_lookup_method (method);
+
+ end = start + code_size;
for (i = 0; i < info->entries; ++i) {
cil_code = info->data [i].cil_code;
if (cil_code && cil_code >= start && cil_code < end) {
+ char *fname = NULL;
offset = cil_code - start;
entry.iloffset = offset;
entry.method = method;
entry.counter = info->data [i].count;
- /* the debug interface doesn't support column info, sigh */
- col = line = 1;
- entry.filename = mono_debug_source_location_from_il_offset (method, offset, &line);
- entry.line = line;
- entry.col = col;
+ entry.line = entry.col = 1;
+ entry.filename = NULL;
+ if (debug_minfo) {
+ MonoDebugSourceLocation *location;
+
+ location = mono_debug_symfile_lookup_location (debug_minfo, offset);
+ if (location) {
+ entry.line = location->row;
+ entry.col = location->column;
+ entry.filename = fname = g_strdup (location->source_file);
+ mono_debug_free_source_location (location);
+ }
+ }
+
func (prof, &entry);
+ g_free (fname);
}
}
}
static void output_callers (MethodProfile *p);
+/* This isn't defined on older glib versions and on some platforms */
+#ifndef G_GUINT64_FORMAT
+#define G_GUINT64_FORMAT "ul"
+#endif
+#ifndef G_GINT64_FORMAT
+#define G_GINT64_FORMAT "lld"
+#endif
+
static void
output_profile (GList *funcs)
{
m = method_get_name (p->method);
fprintf (poutput, "########################\n");
fprintf (poutput, "% 8.3f ", (double) (p->total * 1000));
- fprintf (poutput, "%7llu ", (unsigned long long)p->count);
+ fprintf (poutput, "%7" G_GUINT64_FORMAT " ", (guint64)p->count);
fprintf (poutput, "% 8.3f ", (double) (p->total * 1000)/(double)p->count);
fprintf (poutput, " %s\n", m);
/* callers */
output_callers (p);
}
- fprintf (poutput, "Total number of calls: %lld\n", (long long)total_calls);
+ fprintf (poutput, "Total number of calls: %" G_GINT64_FORMAT "\n", (gint64)total_calls);
}
typedef struct {
}
}
-/* This isn't defined on older glib versions and on some platforms */
-#ifndef G_GUINT64_FORMAT
-#define G_GUINT64_FORMAT "ul"
-#endif
-
static void
output_newobj_profile (GList *proflist)
{
const char *addr_argv[] = {"addr2line", "-f", "-e", binary, NULL};
int child_pid;
int ch_in, ch_out;
+#ifdef __linux__
+ char monobin [1024];
+ /* non-linux platforms will need different code here */
+ if (strcmp (binary, "mono") == 0) {
+ int count = readlink ("/proc/self/exe", monobin, sizeof (monobin));
+ if (count >= 0 && count < sizeof (monobin)) {
+ monobin [count] = 0;
+ addr_argv [3] = monobin;
+ }
+ }
+#endif
if (!g_spawn_async_with_pipes (NULL, (char**)addr_argv, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL,
&child_pid, &ch_in, &ch_out, NULL, NULL)) {
return g_strdup (binary);
simple_appdomain_unload (MonoProfiler *prof, MonoDomain *domain)
{
/* FIXME: we should actually record partial data for each domain,
- * since the ip->ji->method mappings are going away at domain unload time.
+ * but at this point it's must easier using the new logging profiler.
*/
- if (domain == mono_get_root_domain ())
- stat_prof_report ();
+ mono_profiler_shutdown ();
}
+static gint32 simple_shutdown_done = FALSE;
+
static void
simple_shutdown (MonoProfiler *prof)
{
MonoProfiler *tprof;
GSList *tmp;
char *str;
+ gint32 see_shutdown_done;
+
+#ifndef PLATFORM_WIN32
+ mono_thread_attach(mono_get_root_domain());
+#endif
+
+ // Make sure we execute simple_shutdown only once
+ see_shutdown_done = InterlockedExchange(& simple_shutdown_done, TRUE);
+ if (see_shutdown_done)
+ return;
+ if (mono_profiler_events & MONO_PROFILE_STATISTICAL) {
+ stat_prof_report ();
+ }
+
+ // Stop all incoming events
+ mono_profiler_set_events (0);
+
for (tmp = prof->per_thread; tmp; tmp = tmp->next) {
tprof = tmp->data;
merge_thread_data (prof, tprof);
for (ptr = args; ptr && *ptr; ptr++) {
const char *arg = *ptr;
+ // Alwais listen to appdomaon events to shutdown at the first unload
+ flags |= MONO_PROFILE_APPDOMAIN_EVENTS;
if (!strcmp (arg, "time"))
- flags |= MONO_PROFILE_ENTER_LEAVE;
+ flags |= MONO_PROFILE_ENTER_LEAVE | MONO_PROFILE_EXCEPTIONS;
else if (!strcmp (arg, "alloc"))
flags |= MONO_PROFILE_ALLOCATIONS;
else if (!strcmp (arg, "stat"))
- flags |= MONO_PROFILE_STATISTICAL | MONO_PROFILE_APPDOMAIN_EVENTS;
+ flags |= MONO_PROFILE_STATISTICAL;
else if (!strcmp (arg, "jit"))
flags |= MONO_PROFILE_JIT_COMPILATION;
else if (strncmp (arg, "file=", 5) == 0) {
}
}
}
+ if (flags & MONO_PROFILE_ALLOCATIONS)
+ flags |= MONO_PROFILE_ENTER_LEAVE | MONO_PROFILE_EXCEPTIONS;
+ if (!flags)
+ flags = MONO_PROFILE_ENTER_LEAVE | MONO_PROFILE_ALLOCATIONS | MONO_PROFILE_JIT_COMPILATION | MONO_PROFILE_EXCEPTIONS;
prof = create_profiler ();
ALLOC_PROFILER ();
mono_profiler_install (prof, simple_shutdown);
mono_profiler_install_enter_leave (simple_method_enter, simple_method_leave);
+ mono_profiler_install_exception (NULL, simple_method_leave, NULL);
mono_profiler_install_jit_compile (simple_method_jit, simple_method_end_jit);
mono_profiler_install_allocation (simple_allocation);
mono_profiler_install_appdomain (NULL, NULL, simple_appdomain_unload, NULL);
}
#endif
{
- GModule *pmodule;
+ MonoDl *pmodule;
const char* col = strchr (desc, ':');
char* libname;
char* path;
char *mname;
+ char *err;
+ void *iter;
if (col != NULL) {
- mname = g_memdup (desc, col - desc);
+ mname = g_memdup (desc, col - desc + 1);
mname [col - desc] = 0;
} else {
mname = g_strdup (desc);
}
libname = g_strdup_printf ("mono-profiler-%s", mname);
- path = g_module_build_path (NULL, libname);
- pmodule = g_module_open (path, G_MODULE_BIND_LAZY);
- if (pmodule) {
- ProfilerInitializer func;
- if (!g_module_symbol (pmodule, INITIALIZER_NAME, (gpointer *)&func)) {
- g_warning ("Cannot find initializer function %s in profiler module: %s", INITIALIZER_NAME, libname);
- } else {
- func (desc);
+ iter = NULL;
+ err = NULL;
+ while ((path = mono_dl_build_path (NULL, libname, &iter))) {
+ g_free (err);
+ pmodule = mono_dl_open (path, MONO_DL_LAZY, &err);
+ if (pmodule) {
+ ProfilerInitializer func;
+ if ((err = mono_dl_symbol (pmodule, INITIALIZER_NAME, (gpointer *)&func))) {
+ g_warning ("Cannot find initializer function %s in profiler module: %s (%s)", INITIALIZER_NAME, libname, err);
+ g_free (err);
+ err = NULL;
+ } else {
+ func (desc);
+ }
+ break;
}
- } else {
- g_warning ("Error loading profiler module '%s': %s", libname, g_module_error ());
+ g_free (path);
+ }
+ if (!pmodule) {
+ g_warning ("Error loading profiler module '%s': %s", libname, err);
+ g_free (err);
}
-
g_free (libname);
g_free (mname);
g_free (path);