2003-04-24 Martin Baulig <martin@ximian.com>

[mono.git] / mono / metadata / gc.c

diff --git a/mono/metadata/gc.c b/mono/metadata/gc.c
index f63ddba2f7ab5ed5e0bfcea605781808db52196c..9a0dba59c4d36f7543ef3bd987d31444dd6da225 100644 (file)
--- a/mono/metadata/gc.c
+++ b/mono/metadata/gc.c
@@ -26,6 +26,11 @@ static int finalize_slot = -1;
 
 static void object_register_finalizer (MonoObject *obj, void (*callback)(void *, void*));
 
+#if HAVE_BOEHM_GC
+static void finalize_notify (void);
+static HANDLE pending_done_event;
+#endif
+
 /* 
  * 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...
@@ -159,15 +164,24 @@ finalize_static_data (MonoClass *class, MonoVTable *vtable, GHashTable *todo) {
 }
 
 void
-mono_domain_finalize (MonoDomain *domain) {
-
+mono_domain_finalize (MonoDomain *domain) 
+{
        GHashTable *todo = g_hash_table_new (NULL, NULL);
+
+       /* 
+        * No need to create another thread 'cause the finalizer thread
+        * is still working and will take care of running the finalizers
+        */ 
+       mono_thread_new_init (GetCurrentThreadId (), todo, NULL);
+       
 #if HAVE_BOEHM_GC
        GC_gcollect ();
 #endif
        mono_g_hash_table_foreach (domain->class_vtable_hash, (GHFunc)finalize_static_data, todo);
        /* FIXME: finalize objects in todo... */
        g_hash_table_destroy (todo);
+
+       return(0);
 }
 
 void
@@ -224,8 +238,21 @@ void
 ves_icall_System_GC_WaitForPendingFinalizers (void)
 {
        MONO_ARCH_SAVE_REGS;
+       
+#if HAVE_BOEHM_GC
+       if (!GC_should_invoke_finalizers ())
+               return;
+
+       ResetEvent (pending_done_event);
+       finalize_notify ();
+       /* g_print ("Waiting for pending finalizers....\n"); */
+       WaitForSingleObject (pending_done_event, INFINITE);
+       /* g_print ("Done pending....\n"); */
+#else
+#endif
 }
 
+static CRITICAL_SECTION allocator_section;
 static CRITICAL_SECTION handle_section;
 static guint32 next_handle = 0;
 static gpointer *gc_handles = NULL;
@@ -404,18 +431,25 @@ static volatile gboolean finished=FALSE;
 
 static void finalize_notify (void)
 {
+       gboolean pending = GC_should_invoke_finalizers ();
 #ifdef DEBUG
        g_message (G_GNUC_PRETTY_FUNCTION ": prodding finalizer");
 #endif
 
        SetEvent (finalizer_event);
+       if (finished && pending) {
+               /* Finishing the finalizer thread, so wait a little bit... */
+               /* MS seems to wait for about 2 seconds */
+               ResetEvent (pending_done_event);
+               WaitForSingleObject (pending_done_event, 2000);
+       }
 }
 
 static guint32 finalizer_thread (gpointer unused)
 {
        guint32 stack_start;
        
-       mono_new_thread_init (NULL, &stack_start, NULL);
+       mono_thread_new_init (GetCurrentThreadId (), &stack_start, NULL);
        
        while(!finished) {
                /* Wait to be notified that there's at least one
@@ -428,6 +462,7 @@ static guint32 finalizer_thread (gpointer unused)
 #endif
 
                GC_invoke_finalizers ();
+               SetEvent (pending_done_event);
        }
        
        return(0);
@@ -438,13 +473,47 @@ static guint32 finalizer_thread (gpointer unused)
  * It's currently disabled because it still requires some
  * work in the rest of the runtime.
  */
-#undef ENABLE_FINALIZER_THREAD
+#define ENABLE_FINALIZER_THREAD
+
+#ifdef WITH_INCLUDED_LIBGC
+/* from threads.c */
+extern void mono_gc_stop_world (void);
+extern void mono_gc_start_world (void);
+extern void mono_gc_push_all_stacks (void);
+
+static void mono_gc_lock (void)
+{
+       EnterCriticalSection (&allocator_section);
+}
+
+static void mono_gc_unlock (void)
+{
+       LeaveCriticalSection (&allocator_section);
+}
+
+static GCThreadFunctions mono_gc_thread_vtable = {
+       NULL,
+
+       mono_gc_lock,
+       mono_gc_unlock,
+
+       mono_gc_stop_world,
+       NULL,
+       mono_gc_push_all_stacks,
+       mono_gc_start_world
+};
+#endif /* WITH_INCLUDED_LIBGC */
 
 void mono_gc_init (void)
 {
        HANDLE gc_thread;
 
        InitializeCriticalSection (&handle_section);
+       InitializeCriticalSection (&allocator_section);
+
+#ifdef WITH_INCLUDED_LIBGC
+       gc_thread_vtable = &mono_gc_thread_vtable;
+#endif
 
 #ifdef ENABLE_FINALIZER_THREAD
 
@@ -452,7 +521,8 @@ void mono_gc_init (void)
                return;
        
        finalizer_event = CreateEvent (NULL, FALSE, FALSE, NULL);
-       if (finalizer_event == NULL) {
+       pending_done_event = CreateEvent (NULL, TRUE, FALSE, NULL);
+       if (finalizer_event == NULL || pending_done_event == NULL) {
                g_assert_not_reached ();
        }