*
* Author:
* Paolo Molaro (lupus@ximian.com)
+ * Alex Rønne Petersen (alexrp@xamarin.com)
*
* Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
* Copyright 2004-2009 Novell, Inc (http://www.novell.com)
* Copyright 2011 Xamarin Inc (http://www.xamarin.com).
+ * Licensed under the MIT license. See LICENSE file in the project root for full license information.
*/
#include "config.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/metadata/gc-internals.h"
#include "mono/metadata/mono-config-dirs.h"
#include "mono/io-layer/io-layer.h"
#include "mono/utils/mono-dl.h"
+#include <mono/utils/mono-logger-internals.h>
#include <string.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
MonoProfileAppDomainResult domain_end_load;
MonoProfileAppDomainFunc domain_start_unload;
MonoProfileAppDomainFunc domain_end_unload;
+ MonoProfileAppDomainFriendlyNameFunc domain_name;
+
+ MonoProfileContextFunc context_load;
+ MonoProfileContextFunc context_unload;
MonoProfileAssemblyFunc assembly_start_load;
MonoProfileAssemblyResult assembly_end_load;
static ProfilerDesc *prof_list = NULL;
-#define mono_profiler_coverage_lock() mono_mutex_lock (&profiler_coverage_mutex)
-#define mono_profiler_coverage_unlock() mono_mutex_unlock (&profiler_coverage_mutex)
+#define mono_profiler_coverage_lock() mono_os_mutex_lock (&profiler_coverage_mutex)
+#define mono_profiler_coverage_unlock() mono_os_mutex_unlock (&profiler_coverage_mutex)
static mono_mutex_t profiler_coverage_mutex;
/* this is directly accessible to other mono libs.
/**
* mono_profiler_install:
* @prof: a MonoProfiler structure pointer, or a pointer to a derived structure.
- * @version: profiler API version (see profiler.h)
* @callback: the function to invoke at shutdown
*
* Use mono_profiler_install to activate profiling in the Mono runtime.
*
*/
void
-mono_profiler_install (MonoProfiler *prof, int version, MonoProfileFunc callback)
+mono_profiler_install (MonoProfiler *prof, MonoProfileFunc callback)
{
- if (version != MONO_PROFILER_VERSION)
- g_warning ("Profiler module API version (%i) potentially incompatible with current API version (%i)", version, MONO_PROFILER_VERSION);
-
ProfilerDesc *desc = g_new0 (ProfilerDesc, 1);
if (!prof_list)
- mono_mutex_init_recursive (&profiler_coverage_mutex);
+ mono_os_mutex_init_recursive (&profiler_coverage_mutex);
desc->profiler = prof;
desc->shutdown_callback = callback;
desc->next = prof_list;
mono_profiler_set_events (MonoProfileFlags events)
{
ProfilerDesc *prof;
- MonoProfileFlags value = 0;
+ MonoProfileFlags value = (MonoProfileFlags)0;
if (prof_list)
prof_list->events = events;
for (prof = prof_list; prof; prof = prof->next)
- value |= prof->events;
+ value = (MonoProfileFlags)(value | prof->events);
mono_profiler_events = value;
}
void
mono_profiler_install_allocation (MonoProfileAllocFunc callback)
{
+ mono_gc_enable_alloc_events ();
if (!prof_list)
return;
prof_list->allocation_cb = callback;
prof_list->domain_end_unload = end_unload;
}
+void
+mono_profiler_install_appdomain_name (MonoProfileAppDomainFriendlyNameFunc domain_name_cb)
+{
+ if (!prof_list)
+ return;
+
+ prof_list->domain_name = domain_name_cb;
+}
+
+void
+mono_profiler_install_context (MonoProfileContextFunc load, MonoProfileContextFunc unload)
+{
+ if (!prof_list)
+ return;
+
+ prof_list->context_load = load;
+ prof_list->context_unload = unload;
+}
+
void
mono_profiler_install_assembly (MonoProfileAssemblyFunc start_load, MonoProfileAssemblyResult end_load,
MonoProfileAssemblyFunc start_unload, MonoProfileAssemblyFunc end_unload)
}
void
-mono_profiler_allocation (MonoObject *obj, MonoClass *klass)
+mono_profiler_allocation (MonoObject *obj)
{
ProfilerDesc *prof;
for (prof = prof_list; prof; prof = prof->next) {
if ((prof->events & MONO_PROFILE_ALLOCATIONS) && prof->allocation_cb)
- prof->allocation_cb (prof->profiler, obj, klass);
+ prof->allocation_cb (prof->profiler, obj, obj->vtable->klass);
}
}
}
}
+void
+mono_profiler_appdomain_name (MonoDomain *domain, const char *name)
+{
+ for (ProfilerDesc *prof = prof_list; prof; prof = prof->next)
+ if ((prof->events & MONO_PROFILE_APPDOMAIN_EVENTS) && prof->domain_name)
+ prof->domain_name (prof->profiler, domain, name);
+}
+
+void
+mono_profiler_context_loaded (MonoAppContext *context)
+{
+ for (ProfilerDesc *prof = prof_list; prof; prof = prof->next)
+ if ((prof->events & MONO_PROFILE_CONTEXT_EVENTS) && prof->context_load)
+ prof->context_load (prof->profiler, context);
+}
+
+void
+mono_profiler_context_unloaded (MonoAppContext *context)
+{
+ for (ProfilerDesc *prof = prof_list; prof; prof = prof->next)
+ if ((prof->events & MONO_PROFILE_CONTEXT_EVENTS) && prof->context_unload)
+ prof->context_unload (prof->profiler, context);
+}
+
void
mono_profiler_shutdown (void)
{
prof->shutdown_callback (prof->profiler);
}
- mono_profiler_set_events (0);
+ mono_profiler_set_events ((MonoProfileFlags)0);
}
void
if (!coverage_hash)
coverage_hash = g_hash_table_new (NULL, NULL);
- res = g_malloc0 (sizeof (MonoProfileCoverageInfo) + sizeof (void*) * 2 * entries);
+ res = (MonoProfileCoverageInfo *)g_malloc0 (sizeof (MonoProfileCoverageInfo) + sizeof (void*) * 2 * entries);
res->entries = entries;
return;
}
- info = g_hash_table_lookup (coverage_hash, method);
+ info = (MonoProfileCoverageInfo *)g_hash_table_lookup (coverage_hash, method);
if (info) {
g_free (info);
g_hash_table_remove (coverage_hash, method);
void
mono_profiler_coverage_get (MonoProfiler *prof, MonoMethod *method, MonoProfileCoverageFunc func)
{
+ MonoError error;
MonoProfileCoverageInfo* info = NULL;
int i, offset;
guint32 code_size;
mono_profiler_coverage_lock ();
if (coverage_hash)
- info = g_hash_table_lookup (coverage_hash, method);
+ info = (MonoProfileCoverageInfo *)g_hash_table_lookup (coverage_hash, method);
mono_profiler_coverage_unlock ();
if (!info)
return;
- header = mono_method_get_header (method);
+ header = mono_method_get_header_checked (method, &error);
+ mono_error_assert_ok (&error);
start = mono_method_header_get_code (header, &code_size, NULL);
debug_minfo = mono_debug_lookup_method (method);
char *err;
void *iter;
+ mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_ASSEMBLY, "Attempting to load profiler %s from %s (desc %s)", libname, directory, desc);
+
iter = NULL;
err = NULL;
while ((path = mono_dl_build_path (directory, libname, &iter))) {
pmodule = mono_dl_open (path, MONO_DL_LAZY, &err);
+ mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_ASSEMBLY, "Attempting to load profiler: %s %ssuccessful, err: %s", path, pmodule?"":"not ", err);
g_free (path);
g_free (err);
if (pmodule)
gboolean res = FALSE;
if (col != NULL) {
- mname = g_memdup (desc, col - desc + 1);
+ mname = (char *)g_memdup (desc, col - desc + 1);
mname [col - desc] = 0;
} else {
mname = g_strdup (desc);
}
if (!load_embedded_profiler (desc, mname)) {
libname = g_strdup_printf ("mono-profiler-%s", mname);
- if (mono_config_get_assemblies_dir ())
+ char *profiler_lib_dir = getenv ("MONO_PROFILER_LIB_DIR");
+ if (profiler_lib_dir)
+ res = load_profiler_from_directory (profiler_lib_dir, libname, desc);
+ if (!res && mono_config_get_assemblies_dir ())
res = load_profiler_from_directory (mono_assembly_getrootdir (), libname, desc);
if (!res)
res = load_profiler_from_directory (NULL, libname, desc);
projects / mono.git / blobdiff