* Copyright 2002-2003 Ximian, Inc (http://www.ximian.com)
* Copyright 2004-2009 Novell, Inc (http://www.novell.com)
* Copyright 2012 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 <glib.h>
#include <string.h>
-#include <mono/metadata/gc-internal.h>
+#include <mono/metadata/gc-internals.h>
#include <mono/metadata/mono-gc.h>
#include <mono/metadata/threads.h>
#include <mono/metadata/tabledefs.h>
#include <mono/metadata/threadpool-ms.h>
#include <mono/sgen/sgen-conf.h>
#include <mono/sgen/sgen-gc.h>
-#include <mono/utils/mono-logger-internal.h>
-#include <mono/metadata/gc-internal.h>
+#include <mono/utils/mono-logger-internals.h>
+#include <mono/metadata/gc-internals.h>
#include <mono/metadata/marshal.h> /* for mono_delegate_free_ftnptr () */
#include <mono/metadata/attach.h>
#include <mono/metadata/console-io.h>
-#include <mono/utils/mono-semaphore.h>
+#include <mono/utils/mono-os-semaphore.h>
#include <mono/utils/mono-memory-model.h>
#include <mono/utils/mono-counters.h>
#include <mono/utils/mono-time.h>
#include <mono/utils/dtrace.h>
#include <mono/utils/mono-threads.h>
#include <mono/utils/atomic.h>
+#include <mono/utils/mono-coop-semaphore.h>
+#include <mono/utils/hazard-pointer.h>
#ifndef HOST_WIN32
#include <pthread.h>
static gboolean finalizing_root_domain = FALSE;
gboolean log_finalizers = FALSE;
-gboolean do_not_finalize = FALSE;
+gboolean mono_do_not_finalize = FALSE;
+gchar **mono_do_not_finalize_class_names = NULL;
-#define mono_finalizer_lock() mono_mutex_lock (&finalizer_mutex)
-#define mono_finalizer_unlock() mono_mutex_unlock (&finalizer_mutex)
-static mono_mutex_t finalizer_mutex;
-static mono_mutex_t reference_queue_mutex;
+#define mono_finalizer_lock() mono_coop_mutex_lock (&finalizer_mutex)
+#define mono_finalizer_unlock() mono_coop_mutex_unlock (&finalizer_mutex)
+static MonoCoopMutex finalizer_mutex;
+static MonoCoopMutex reference_queue_mutex;
static GSList *domains_to_finalize= NULL;
static MonoMList *threads_to_finalize = NULL;
static gboolean finalizer_thread_exited;
/* Uses finalizer_mutex */
-static mono_cond_t exited_cond;
+static MonoCoopCond exited_cond;
static MonoInternalThread *gc_thread;
-static void object_register_finalizer (MonoObject *obj, void (*callback)(void *, void*));
+static void object_register_finalizer (MonoObject *obj, void (*callback)(void *, void*), MonoError *error);
static void reference_queue_proccess_all (void);
static void mono_reference_queue_cleanup (void);
void
mono_gc_run_finalize (void *obj, void *data)
{
- if (do_not_finalize)
- return;
-
+ MonoError error;
MonoObject *exc = NULL;
MonoObject *o;
#ifndef HAVE_SGEN_GC
RuntimeInvokeFunction runtime_invoke;
// This function is called from the innards of the GC, so our best alternative for now is to do polling here
- MONO_SUSPEND_CHECK ();
+ mono_threads_safepoint ();
o = (MonoObject*)((char*)obj + GPOINTER_TO_UINT (data));
+ if (mono_do_not_finalize) {
+ if (!mono_do_not_finalize_class_names)
+ return;
+
+ size_t namespace_len = strlen (o->vtable->klass->name_space);
+ for (int i = 0; mono_do_not_finalize_class_names [i]; ++i) {
+ const char *name = mono_do_not_finalize_class_names [i];
+ if (strncmp (name, o->vtable->klass->name_space, namespace_len))
+ break;
+ if (name [namespace_len] != '.')
+ break;
+ if (strcmp (name + namespace_len + 1, o->vtable->klass->name))
+ break;
+ return;
+ }
+ }
+
if (log_finalizers)
g_log ("mono-gc-finalizers", G_LOG_LEVEL_DEBUG, "<%s at %p> Starting finalizer checks.", o->vtable->klass->name, o);
#ifndef HAVE_SGEN_GC
mono_domain_finalizers_lock (domain);
- o2 = g_hash_table_lookup (domain->finalizable_objects_hash, o);
+ o2 = (MonoObject *)g_hash_table_lookup (domain->finalizable_objects_hash, o);
mono_domain_finalizers_unlock (domain);
#endif
/* make sure the finalizer is not called again if the object is resurrected */
- object_register_finalizer (obj, NULL);
+ object_register_finalizer ((MonoObject *)obj, NULL, &error);
+ mono_error_assert_ok (&error); /* FIXME don't swallow the error */
if (log_finalizers)
g_log ("mono-gc-finalizers", G_LOG_LEVEL_MESSAGE, "<%s at %p> Registered finalizer as processed.", o->vtable->klass->name, o);
}
/*
- * To avoid the locking plus the other overhead of mono_runtime_invoke (),
+ * To avoid the locking plus the other overhead of mono_runtime_invoke_checked (),
* create and precompile a wrapper which calls the finalize method using
* a CALLVIRT.
*/
domain->finalize_runtime_invoke = mono_compile_method (invoke);
}
- runtime_invoke = domain->finalize_runtime_invoke;
+ runtime_invoke = (RuntimeInvokeFunction)domain->finalize_runtime_invoke;
- mono_runtime_class_init (o->vtable);
+ mono_runtime_class_init_full (o->vtable, &error);
+ mono_error_raise_exception (&error); /* FIXME don't raise here */
if (G_UNLIKELY (MONO_GC_FINALIZE_INVOKE_ENABLED ())) {
MONO_GC_FINALIZE_INVOKE ((unsigned long)o, mono_object_get_size (o),
void
mono_gc_finalize_threadpool_threads (void)
{
+ MonoError error;
while (threads_to_finalize) {
MonoInternalThread *thread = (MonoInternalThread*) mono_mlist_get_data (threads_to_finalize);
/* Force finalization of the thread. */
thread->threadpool_thread = FALSE;
- mono_object_register_finalizer ((MonoObject*)thread);
+ mono_object_register_finalizer ((MonoObject*)thread, &error);
+ mono_error_assert_ok (&error); /* FIXME don't swallow the error */
mono_gc_run_finalize (thread, NULL);
* since that, too, can cause the underlying pointer to be offset.
*/
static void
-object_register_finalizer (MonoObject *obj, void (*callback)(void *, void*))
+object_register_finalizer (MonoObject *obj, void (*callback)(void *, void*), MonoError *error)
{
MonoDomain *domain;
- if (obj == NULL)
- mono_raise_exception (mono_get_exception_argument_null ("obj"));
+ mono_error_init (error);
+
+ if (obj == NULL) {
+ mono_error_set_argument_null (error, "obj", "");
+ return;
+ }
domain = obj->vtable->domain;
* end up running them while or after the domain is being cleared, so
* the objects will not be valid anymore.
*/
- if (!mono_domain_is_unloading (domain)) {
- MONO_TRY_BLOCKING;
+ if (!mono_domain_is_unloading (domain))
mono_gc_register_for_finalization (obj, callback);
- MONO_FINISH_TRY_BLOCKING;
- }
#endif
}
*
*/
void
-mono_object_register_finalizer (MonoObject *obj)
+mono_object_register_finalizer (MonoObject *obj, MonoError *error)
{
/* g_print ("Registered finalizer on %p %s.%s\n", obj, mono_object_class (obj)->name_space, mono_object_class (obj)->name); */
- object_register_finalizer (obj, mono_gc_run_finalize);
+ object_register_finalizer (obj, mono_gc_run_finalize, error);
}
/**
mono_gc_finalize_threadpool_threads ();
}
+ mono_profiler_appdomain_event (domain, MONO_PROFILE_END_UNLOAD);
+
return TRUE;
}
void
ves_icall_System_GC_ReRegisterForFinalize (MonoObject *obj)
{
+ MonoError error;
+
MONO_CHECK_ARG_NULL (obj,);
- object_register_finalizer (obj, mono_gc_run_finalize);
+ object_register_finalizer (obj, mono_gc_run_finalize, &error);
+ mono_error_set_pending_exception (&error);
}
void
ves_icall_System_GC_SuppressFinalize (MonoObject *obj)
{
+ MonoError error;
+
MONO_CHECK_ARG_NULL (obj,);
/* delegates have no finalizers, but we register them to deal with the
* generated for it that needs cleaned up, but user wants to suppress
* their derived object finalizer. */
- object_register_finalizer (obj, NULL);
+ object_register_finalizer (obj, NULL, &error);
+ mono_error_set_pending_exception (&error);
}
void
return mono_domain_get ()->ephemeron_tombstone;
}
-#define mono_allocator_lock() mono_mutex_lock (&allocator_section)
-#define mono_allocator_unlock() mono_mutex_unlock (&allocator_section)
-static mono_mutex_t allocator_section;
-
MonoObject *
ves_icall_System_GCHandle_GetTarget (guint32 handle)
{
return NULL;
}
-MonoBoolean
-ves_icall_Mono_Runtime_SetGCAllowSynchronousMajor (MonoBoolean flag)
-{
- return mono_gc_set_allow_synchronous_major (flag);
-}
-
MonoBoolean
mono_gc_GCHandle_CheckCurrentDomain (guint32 gchandle)
{
return mono_gchandle_is_in_domain (gchandle, mono_domain_get ());
}
-#ifdef MONO_HAS_SEMAPHORES
-static MonoSemType finalizer_sem;
-#endif
-static HANDLE finalizer_event;
+static MonoCoopSem finalizer_sem;
static volatile gboolean finished=FALSE;
void
if (mono_gc_is_null ())
return;
-#ifdef MONO_HAS_SEMAPHORES
- MONO_SEM_POST (&finalizer_sem);
-#else
- SetEvent (finalizer_event);
-#endif
+ mono_coop_sem_post (&finalizer_sem);
+}
+
+/*
+This is the number of entries allowed in the hazard free queue before
+we explicitly cycle the finalizer thread to trigger pumping the queue.
+
+It was picked empirically by running the corlib test suite in a stress
+scenario where all hazard entries are queued.
+
+In this extreme scenario we double the number of times we cycle the finalizer
+thread compared to just GC calls.
+
+Entries are usually in the order of 100's of bytes each, so we're limiting
+floating garbage to be in the order of a dozen kb.
+*/
+static gboolean finalizer_thread_pulsed;
+#define HAZARD_QUEUE_OVERFLOW_SIZE 20
+
+static void
+hazard_free_queue_is_too_big (size_t size)
+{
+ if (size < HAZARD_QUEUE_OVERFLOW_SIZE)
+ return;
+
+ if (finalizer_thread_pulsed || InterlockedCompareExchange (&finalizer_thread_pulsed, TRUE, FALSE))
+ return;
+
+ mono_gc_finalize_notify ();
+}
+
+static void
+hazard_free_queue_pump (void)
+{
+ mono_thread_hazardous_try_free_all ();
+ finalizer_thread_pulsed = FALSE;
}
#ifdef HAVE_BOEHM_GC
static guint32
finalizer_thread (gpointer unused)
{
+ MonoError error;
+ mono_thread_set_name_internal (mono_thread_internal_current (), mono_string_new (mono_get_root_domain (), "Finalizer"), FALSE, &error);
+ mono_error_assert_ok (&error);
+
gboolean wait = TRUE;
+ /* Register a hazard free queue pump callback */
+ mono_hazard_pointer_install_free_queue_size_callback (hazard_free_queue_is_too_big);
+
while (!finished) {
/* Wait to be notified that there's at least one
* finaliser to run
g_assert (mono_domain_get () == mono_get_root_domain ());
mono_gc_set_skip_thread (TRUE);
- MONO_PREPARE_BLOCKING;
if (wait) {
- /* An alertable wait is required so this thread can be suspended on windows */
-#ifdef MONO_HAS_SEMAPHORES
- MONO_SEM_WAIT_ALERTABLE (&finalizer_sem, TRUE);
-#else
- WaitForSingleObjectEx (finalizer_event, INFINITE, TRUE);
-#endif
+ /* An alertable wait is required so this thread can be suspended on windows */
+ mono_coop_sem_wait (&finalizer_sem, MONO_SEM_FLAGS_ALERTABLE);
}
wait = TRUE;
- MONO_FINISH_BLOCKING;
+
mono_gc_set_skip_thread (FALSE);
mono_threads_perform_thread_dump ();
if (domains_to_finalize) {
mono_finalizer_lock ();
if (domains_to_finalize) {
- DomainFinalizationReq *req = domains_to_finalize->data;
+ DomainFinalizationReq *req = (DomainFinalizationReq *)domains_to_finalize->data;
domains_to_finalize = g_slist_remove (domains_to_finalize, req);
mono_finalizer_unlock ();
reference_queue_proccess_all ();
-#ifdef MONO_HAS_SEMAPHORES
+ hazard_free_queue_pump ();
+
/* Avoid posting the pending done event until there are pending finalizers */
- if (MONO_SEM_TIMEDWAIT (&finalizer_sem, 0) == 0)
+ if (mono_coop_sem_timedwait (&finalizer_sem, 0, MONO_SEM_FLAGS_NONE) == 0) {
/* Don't wait again at the start of the loop */
wait = FALSE;
- else
- SetEvent (pending_done_event);
-#else
+ } else {
SetEvent (pending_done_event);
-#endif
+ }
}
mono_finalizer_lock ();
finalizer_thread_exited = TRUE;
- mono_cond_signal (&exited_cond);
+ mono_coop_cond_signal (&exited_cond);
mono_finalizer_unlock ();
return 0;
void
mono_gc_init_finalizer_thread (void)
{
- gc_thread = mono_thread_create_internal (mono_domain_get (), finalizer_thread, NULL, FALSE, 0);
- ves_icall_System_Threading_Thread_SetName_internal (gc_thread, mono_string_new (mono_domain_get (), "Finalizer"));
+ MonoError error;
+ gc_thread = mono_thread_create_internal (mono_domain_get (), finalizer_thread, NULL, FALSE, 0, &error);
+ mono_error_assert_ok (&error);
}
void
mono_gc_init (void)
{
- mono_mutex_init_recursive (&allocator_section);
-
- mono_mutex_init_recursive (&finalizer_mutex);
- mono_mutex_init_recursive (&reference_queue_mutex);
+ mono_coop_mutex_init_recursive (&finalizer_mutex);
+ mono_coop_mutex_init_recursive (&reference_queue_mutex);
mono_counters_register ("Minor GC collections", MONO_COUNTER_GC | MONO_COUNTER_UINT, &gc_stats.minor_gc_count);
mono_counters_register ("Major GC collections", MONO_COUNTER_GC | MONO_COUNTER_UINT, &gc_stats.major_gc_count);
gc_disabled = TRUE;
return;
}
-
- finalizer_event = CreateEvent (NULL, FALSE, FALSE, NULL);
- g_assert (finalizer_event);
+
pending_done_event = CreateEvent (NULL, TRUE, FALSE, NULL);
g_assert (pending_done_event);
- mono_cond_init (&exited_cond, 0);
-#ifdef MONO_HAS_SEMAPHORES
- MONO_SEM_INIT (&finalizer_sem, 0);
-#endif
+ mono_coop_cond_init (&exited_cond);
+ mono_coop_sem_init (&finalizer_sem, 0);
#ifndef LAZY_GC_THREAD_CREATION
mono_gc_init_finalizer_thread ();
finished = TRUE;
if (mono_thread_internal_current () != gc_thread) {
gboolean timed_out = FALSE;
- guint32 start_ticks = mono_msec_ticks ();
- guint32 end_ticks = start_ticks + 2000;
+ gint64 start_ticks = mono_msec_ticks ();
+ gint64 end_ticks = start_ticks + 2000;
mono_gc_finalize_notify ();
/* Finishing the finalizer thread, so wait a little bit... */
/* MS seems to wait for about 2 seconds */
while (!finalizer_thread_exited) {
- guint32 current_ticks = mono_msec_ticks ();
+ gint64 current_ticks = mono_msec_ticks ();
guint32 timeout;
if (current_ticks >= end_ticks)
break;
else
timeout = end_ticks - current_ticks;
- MONO_PREPARE_BLOCKING;
mono_finalizer_lock ();
if (!finalizer_thread_exited)
- mono_cond_timedwait_ms (&exited_cond, &finalizer_mutex, timeout);
+ mono_coop_cond_timedwait (&exited_cond, &finalizer_mutex, timeout);
mono_finalizer_unlock ();
- MONO_FINISH_BLOCKING;
}
if (!finalizer_thread_exited) {
mono_thread_join (GUINT_TO_POINTER (gc_thread->tid));
}
+ g_assert (finalizer_thread_exited);
}
gc_thread = NULL;
mono_gc_base_cleanup ();
mono_reference_queue_cleanup ();
- mono_mutex_destroy (&allocator_section);
- mono_mutex_destroy (&finalizer_mutex);
- mono_mutex_destroy (&reference_queue_mutex);
+ mono_coop_mutex_destroy (&finalizer_mutex);
+ mono_coop_mutex_destroy (&reference_queue_mutex);
}
gboolean
* This routine tests whether the @thread argument represents the
* finalization thread.
*
- * Returns true if @thread is the finalization thread.
+ * Returns: TRUE if @thread is the finalization thread.
*/
gboolean
mono_gc_is_finalizer_thread (MonoThread *thread)
}
#endif
-#ifndef HAVE_SGEN_GC
-void*
-mono_gc_alloc_mature (MonoVTable *vtable)
-{
- return mono_object_new_specific (vtable);
-}
-#endif
-
-
static MonoReferenceQueue *ref_queues;
static void
/* Guard if head is changed concurrently. */
while (*prev != element)
prev = &(*prev)->next;
- } while (prev && InterlockedCompareExchangePointer ((void*)prev, element->next, element) != element);
+ } while (prev && InterlockedCompareExchangePointer ((volatile gpointer *)prev, element->next, element) != element);
}
static void
current = *head;
value->next = current;
STORE_STORE_FENCE; /*Must make sure the previous store is visible before the CAS. */
- } while (InterlockedCompareExchangePointer ((void*)head, value, current) != current);
+ } while (InterlockedCompareExchangePointer ((volatile gpointer *)head, value, current) != current);
}
static void
reference_queue_proccess (queue);
restart:
- mono_mutex_lock (&reference_queue_mutex);
+ mono_coop_mutex_lock (&reference_queue_mutex);
for (iter = &ref_queues; *iter;) {
queue = *iter;
if (!queue->should_be_deleted) {
continue;
}
if (queue->queue) {
- mono_mutex_unlock (&reference_queue_mutex);
+ mono_coop_mutex_unlock (&reference_queue_mutex);
reference_queue_proccess (queue);
goto restart;
}
*iter = queue->next;
g_free (queue);
}
- mono_mutex_unlock (&reference_queue_mutex);
+ mono_coop_mutex_unlock (&reference_queue_mutex);
}
static void
MonoReferenceQueue *res = g_new0 (MonoReferenceQueue, 1);
res->callback = callback;
- mono_mutex_lock (&reference_queue_mutex);
+ mono_coop_mutex_lock (&reference_queue_mutex);
res->next = ref_queues;
ref_queues = res;
- mono_mutex_unlock (&reference_queue_mutex);
+ mono_coop_mutex_unlock (&reference_queue_mutex);
return res;
}
gboolean
mono_gc_reference_queue_add (MonoReferenceQueue *queue, MonoObject *obj, void *user_data)
{
+ MonoError error;
RefQueueEntry *entry;
if (queue->should_be_deleted)
return FALSE;
entry->domain = mono_object_domain (obj);
entry->gchandle = mono_gchandle_new_weakref (obj, TRUE);
- mono_object_register_finalizer (obj);
+ mono_object_register_finalizer (obj, &error);
+ mono_error_assert_ok (&error);
ref_list_push (&queue->queue, entry);
return TRUE;
projects / mono.git / blobdiff