#include <mono/metadata/metadata-internals.h>
#include <mono/metadata/mono-mlist.h>
#include <mono/metadata/threads-types.h>
-#include <mono/metadata/threadpool-ms.h>
+#include <mono/metadata/threadpool.h>
#include <mono/sgen/sgen-conf.h>
#include <mono/sgen/sgen-gc.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/atomic.h>
#include <mono/utils/mono-coop-semaphore.h>
#include <mono/utils/hazard-pointer.h>
+#include <mono/utils/w32api.h>
#ifndef HOST_WIN32
#include <pthread.h>
static MonoCoopMutex reference_queue_mutex;
static GSList *domains_to_finalize;
-static MonoMList *threads_to_finalize;
static gboolean finalizer_thread_exited;
/* Uses finalizer_mutex */
return res;
}
-static gboolean
-add_thread_to_finalize (MonoInternalThread *thread, MonoError *error)
-{
- mono_error_init (error);
- mono_finalizer_lock ();
- if (!threads_to_finalize)
- MONO_GC_REGISTER_ROOT_SINGLE (threads_to_finalize, MONO_ROOT_SOURCE_FINALIZER_QUEUE, "finalizable threads list");
- threads_to_finalize = mono_mlist_append_checked (threads_to_finalize, (MonoObject*)thread, error);
- mono_finalizer_unlock ();
- return is_ok (error);
-}
-
/*
* actually, we might want to queue the finalize requests in a separate thread,
* but we need to be careful about the execution domain of the thread...
if (mono_gc_is_finalizer_internal_thread (t))
/* Avoid finalizing ourselves */
return;
-
- if (t->threadpool_thread && finalizing_root_domain) {
- /* Don't finalize threadpool threads when
- shutting down - they're finalized when the
- threadpool shuts down. */
- if (!add_thread_to_finalize (t, &error))
- goto unhandled_error;
- return;
- }
}
if (o->vtable->klass->image == mono_defaults.corlib && !strcmp (o->vtable->klass->name, "DynamicMethod") && finalizing_root_domain) {
mono_domain_set_internal (caller_domain);
}
-void
-mono_gc_finalize_threadpool_threads (void)
-{
- 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_gc_run_finalize (thread, NULL);
-
- threads_to_finalize = mono_mlist_next (threads_to_finalize);
- }
-}
-
gpointer
mono_gc_out_of_memory (size_t size)
{
goto done;
}
- if (domain == mono_get_root_domain ()) {
- mono_threadpool_ms_cleanup ();
- mono_gc_finalize_threadpool_threads ();
- }
-
done:
if (InterlockedDecrement (&req->ref) == 0) {
mono_coop_sem_destroy (&req->done);
}
}
-static guint32
+static gsize WINAPI
finalizer_thread (gpointer unused)
{
MonoError error;
gboolean wait = TRUE;
- mono_thread_set_name_internal (mono_thread_internal_current (), mono_string_new (mono_get_root_domain (), "Finalizer"), FALSE, &error);
+ mono_thread_set_name_internal (mono_thread_internal_current (), mono_string_new (mono_get_root_domain (), "Finalizer"), FALSE, FALSE, &error);
mono_error_assert_ok (&error);
/* Register a hazard free queue pump callback */
finished = TRUE;
if (mono_thread_internal_current () != gc_thread) {
int ret;
- gint64 start_ticks = mono_msec_ticks ();
- gint64 end_ticks = start_ticks + 2000;
+ gint64 start;
+ const gint64 timeout = 40 * 1000;
mono_gc_finalize_notify ();
+
+ start = mono_msec_ticks ();
+
/* Finishing the finalizer thread, so wait a little bit... */
- /* MS seems to wait for about 2 seconds */
- while (!finalizer_thread_exited) {
- gint64 current_ticks = mono_msec_ticks ();
- guint32 timeout;
+ /* MS seems to wait for about 2 seconds per finalizer thread */
+ /* and 40 seconds for all finalizers to finish */
+ for (;;) {
+ gint64 elapsed;
+
+ if (finalizer_thread_exited) {
+ /* Wait for the thread to actually exit. We don't want the wait
+ * to be alertable, because we assert on the result to be SUCCESS_0 */
+ ret = guarded_wait (gc_thread->handle, MONO_INFINITE_WAIT, FALSE);
+ g_assert (ret == MONO_THREAD_INFO_WAIT_RET_SUCCESS_0);
+
+ mono_thread_join (GUINT_TO_POINTER (gc_thread->tid));
+ break;
+ }
+
+ elapsed = mono_msec_ticks () - start;
+ if (elapsed >= timeout) {
+ /* timeout */
+
+ /* Set a flag which the finalizer thread can check */
+ suspend_finalizers = TRUE;
+ mono_gc_suspend_finalizers ();
+
+ /* Try to abort the thread, in the hope that it is running managed code */
+ mono_thread_internal_abort (gc_thread);
+
+ /* Wait for it to stop */
+ ret = guarded_wait (gc_thread->handle, 100, FALSE);
+ if (ret == MONO_THREAD_INFO_WAIT_RET_TIMEOUT) {
+ /* The finalizer thread refused to exit, suspend it forever. */
+ mono_thread_internal_suspend_for_shutdown (gc_thread);
+ break;
+ }
- if (current_ticks >= end_ticks)
+ g_assert (ret == MONO_THREAD_INFO_WAIT_RET_SUCCESS_0);
+
+ mono_thread_join (GUINT_TO_POINTER (gc_thread->tid));
break;
- else
- timeout = end_ticks - current_ticks;
+ }
+
mono_finalizer_lock ();
if (!finalizer_thread_exited)
- mono_coop_cond_timedwait (&exited_cond, &finalizer_mutex, timeout);
+ mono_coop_cond_timedwait (&exited_cond, &finalizer_mutex, timeout - elapsed);
mono_finalizer_unlock ();
}
-
- if (!finalizer_thread_exited) {
- /* Set a flag which the finalizer thread can check */
- suspend_finalizers = TRUE;
- mono_gc_suspend_finalizers ();
-
- /* Try to abort the thread, in the hope that it is running managed code */
- mono_thread_internal_abort (gc_thread);
-
- /* Wait for it to stop */
- ret = guarded_wait (gc_thread->handle, 100, TRUE);
-
- if (ret == MONO_THREAD_INFO_WAIT_RET_TIMEOUT) {
- /*
- * The finalizer thread refused to exit. Make it stop.
- */
- mono_thread_internal_stop (gc_thread);
- ret = guarded_wait (gc_thread->handle, 100, TRUE);
- g_assert (ret != MONO_THREAD_INFO_WAIT_RET_TIMEOUT);
- /* The thread can't set this flag */
- finalizer_thread_exited = TRUE;
- }
- }
-
-
- /* Wait for the thread to actually exit */
- ret = guarded_wait (gc_thread->handle, MONO_INFINITE_WAIT, TRUE);
- g_assert (ret == MONO_THREAD_INFO_WAIT_RET_SUCCESS_0);
-
- mono_thread_join (GUINT_TO_POINTER (gc_thread->tid));
- g_assert (finalizer_thread_exited);
}
gc_thread = NULL;
mono_gc_base_cleanup ();