* boehm-gc.c: GC implementation using either the installed or included Boehm GC.
*
* Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
- * Copyright 2004-2009 Novell, Inc (http://www.novell.com)
+ * Copyright 2004-2011 Novell, Inc (http://www.novell.com)
+ * Copyright 2011-2012 Xamarin, Inc (http://www.xamarin.com)
*/
#include "config.h"
#include <mono/metadata/domain-internals.h>
#include <mono/metadata/metadata-internals.h>
#include <mono/metadata/marshal.h>
+#include <mono/metadata/runtime.h>
#include <mono/utils/mono-logger-internal.h>
#include <mono/utils/mono-time.h>
#include <mono/utils/mono-threads.h>
#include "private/pthread_support.h"
#endif
+#if defined(PLATFORM_MACOSX) && defined(HAVE_PTHREAD_GET_STACKADDR_NP)
+void *pthread_get_stackaddr_np(pthread_t);
+#endif
+
#define GC_NO_DESCRIPTOR ((gpointer)(0 | GC_DS_LENGTH))
/*Boehm max heap cannot be smaller than 16MB*/
#define MIN_BOEHM_MAX_HEAP_SIZE_IN_MB 16
}
continue;
} else {
+ /* Could be a parameter for sgen */
+ /*
fprintf (stderr, "MONO_GC_PARAMS must be a comma-delimited list of one or more of the following:\n");
fprintf (stderr, " max-heap-size=N (where N is an integer, possibly with a k, m or a g suffix)\n");
exit (1);
+ */
}
}
g_strfreev (opts);
memset (&cb, 0, sizeof (cb));
cb.thread_register = boehm_thread_register;
+ cb.mono_method_is_critical = (gpointer)mono_runtime_is_critical_method;
+#ifndef HOST_WIN32
+ cb.mono_gc_pthread_create = (gpointer)mono_gc_pthread_create;
+#endif
+
mono_threads_init (&cb, sizeof (MonoThreadInfo));
mono_gc_enable_events ();
void
mono_gc_collect (int generation)
{
- MONO_PROBE_GC_BEGIN (generation);
+ MONO_GC_BEGIN (generation);
+#ifndef DISABLE_PERFCOUNTERS
mono_perfcounters->gc_induced++;
+#endif
GC_gcollect ();
- MONO_PROBE_GC_END (generation);
+ MONO_GC_END (generation);
#if defined(ENABLE_DTRACE) && defined(__sun__)
/* This works around a dtrace -G problem on Solaris.
Limit its actual use to when the probe is enabled. */
- if (MONO_PROBE_GC_END_ENABLED ())
+ if (MONO_GC_END_ENABLED ())
sleep(0);
#endif
}
{
MonoGCEvent e = (MonoGCEvent)event;
+ if (e == MONO_GC_EVENT_PRE_STOP_WORLD)
+ mono_thread_info_suspend_lock ();
+ else if (e == MONO_GC_EVENT_POST_START_WORLD)
+ mono_thread_info_suspend_unlock ();
+
if (e == MONO_GC_EVENT_START) {
- mono_perfcounters->gc_collections0++;
- mono_stats.major_gc_count ++;
+#ifndef DISABLE_PERFCOUNTERS
+ if (mono_perfcounters)
+ mono_perfcounters->gc_collections0++;
+#endif
+ gc_stats.major_gc_count ++;
gc_start_time = mono_100ns_ticks ();
} else if (e == MONO_GC_EVENT_END) {
- guint64 heap_size = GC_get_heap_size ();
- guint64 used_size = heap_size - GC_get_free_bytes ();
- mono_perfcounters->gc_total_bytes = used_size;
- mono_perfcounters->gc_committed_bytes = heap_size;
- mono_perfcounters->gc_reserved_bytes = heap_size;
- mono_perfcounters->gc_gen0size = heap_size;
- mono_stats.major_gc_time_usecs += (mono_100ns_ticks () - gc_start_time) / 10;
+#ifndef DISABLE_PERFCOUNTERS
+ if (mono_perfcounters) {
+ guint64 heap_size = GC_get_heap_size ();
+ guint64 used_size = heap_size - GC_get_free_bytes ();
+ mono_perfcounters->gc_total_bytes = used_size;
+ mono_perfcounters->gc_committed_bytes = heap_size;
+ mono_perfcounters->gc_reserved_bytes = heap_size;
+ mono_perfcounters->gc_gen0size = heap_size;
+ }
+#endif
+ gc_stats.major_gc_time_usecs += (mono_100ns_ticks () - gc_start_time) / 10;
mono_trace_message (MONO_TRACE_GC, "gc took %d usecs", (mono_100ns_ticks () - gc_start_time) / 10);
}
mono_profiler_gc_event (e, 0);
on_gc_heap_resize (size_t new_size)
{
guint64 heap_size = GC_get_heap_size ();
- mono_perfcounters->gc_committed_bytes = heap_size;
- mono_perfcounters->gc_reserved_bytes = heap_size;
- mono_perfcounters->gc_gen0size = heap_size;
+#ifndef DISABLE_PERFCOUNTERS
+ if (mono_perfcounters) {
+ mono_perfcounters->gc_committed_bytes = heap_size;
+ mono_perfcounters->gc_reserved_bytes = heap_size;
+ mono_perfcounters->gc_gen0size = heap_size;
+ }
+#endif
mono_profiler_gc_heap_resize (new_size);
}
void
mono_gc_wbarrier_arrayref_copy (gpointer dest_ptr, gpointer src_ptr, int count)
{
- memmove (dest_ptr, src_ptr, count * sizeof (gpointer));
+ mono_gc_memmove (dest_ptr, src_ptr, count * sizeof (gpointer));
}
void
void
mono_gc_wbarrier_value_copy (gpointer dest, gpointer src, int count, MonoClass *klass)
{
- memmove (dest, src, count * mono_class_value_size (klass, NULL));
+ mono_gc_memmove (dest, src, count * mono_class_value_size (klass, NULL));
}
void
mono_gc_wbarrier_object_copy (MonoObject* obj, MonoObject *src)
{
/* do not copy the sync state */
- memcpy ((char*)obj + sizeof (MonoObject), (char*)src + sizeof (MonoObject),
+ mono_gc_memmove ((char*)obj + sizeof (MonoObject), (char*)src + sizeof (MonoObject),
mono_object_class (obj)->instance_size - sizeof (MonoObject));
}
static MonoMethod* alloc_method_cache [ATYPE_NUM];
-gboolean
+static G_GNUC_UNUSED gboolean
mono_gc_is_critical_method (MonoMethod *method)
{
int i;
- if (method == write_barrier_method)
- return TRUE;
for (i = 0; i < ATYPE_NUM; ++i)
if (method == alloc_method_cache [i])
#else
-gboolean
+static G_GNUC_UNUSED gboolean
mono_gc_is_critical_method (MonoMethod *method)
{
return FALSE;
return NULL;
}
+void
+mono_gc_set_current_thread_appdomain (MonoDomain *domain)
+{
+}
+
gboolean
mono_gc_precise_stack_mark_enabled (void)
{
{
}
+void
+mono_gc_set_stack_end (void *stack_end)
+{
+}
+
+void mono_gc_set_skip_thread (gboolean value)
+{
+}
+
/*
* These will call the redefined versions in libgc.
*/
int
mono_gc_pthread_create (pthread_t *new_thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg)
{
- return mono_threads_pthread_create (new_thread, attr, start_routine, arg);
+ return pthread_create (new_thread, attr, start_routine, arg);
}
int
return pthread_detach (thread);
}
+void
+mono_gc_pthread_exit (void *retval)
+{
+ pthread_exit (retval);
+}
+
#endif
#ifdef HOST_WIN32
}
#endif
+guint
+mono_gc_get_vtable_bits (MonoClass *class)
+{
+ return 0;
+}
+
+/*
+ * mono_gc_register_altstack:
+ *
+ * Register the dimensions of the normal stack and altstack with the collector.
+ * Currently, STACK/STACK_SIZE is only used when the thread is suspended while it is on an altstack.
+ */
+void
+mono_gc_register_altstack (gpointer stack, gint32 stack_size, gpointer altstack, gint32 altstack_size)
+{
+#ifdef USE_INCLUDED_LIBGC
+ GC_register_altstack (stack, stack_size, altstack, altstack_size);
+#endif
+}
+
+int
+mono_gc_get_los_limit (void)
+{
+ return G_MAXINT;
+}
+
+gboolean
+mono_gc_user_markers_supported (void)
+{
+ return FALSE;
+}
+
+void *
+mono_gc_make_root_descr_user (MonoGCRootMarkFunc marker)
+{
+ g_assert_not_reached ();
+ return NULL;
+}
+
#endif /* no Boehm GC */
projects / mono.git / blobdiff