Attachment 182687 Details for Bug 337383

[patch] racefix.diff

racefix.diff (text/plain), 7.04 KB, created by Mark Probst on 2007-11-08 18:24:15 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Mark Probst

Created: 2007-11-08 18:24:15 UTC

Size: 7.04 KB

patch

obsolete

>Index: metadata/gc-internal.h
>===================================================================
>--- metadata/gc-internal.h	(revision 89087)
>+++ metadata/gc-internal.h	(working copy)
>@@ -88,6 +88,8 @@
> void  mono_gc_deregister_root (char* addr) MONO_INTERNAL;
> int   mono_gc_finalizers_for_domain (MonoDomain *domain, MonoObject **out_array, int out_size) MONO_INTERNAL;
> 
>+void  mono_gc_finalize_threadpool_threads (void) MONO_INTERNAL;
>+
> /* fast allocation support */
> MonoMethod* mono_gc_get_managed_allocator (MonoVTable *vtable, gboolean for_box) MONO_INTERNAL;
> int mono_gc_get_managed_allocator_type (MonoMethod *managed_alloc) MONO_INTERNAL;
>Index: metadata/threads.c
>===================================================================
>--- metadata/threads.c	(revision 89087)
>+++ metadata/threads.c	(working copy)
>@@ -602,7 +602,7 @@
> 	return default_stacksize;
> }
> 
>-void mono_thread_create (MonoDomain *domain, gpointer func, gpointer arg)
>+void mono_thread_create_internal (MonoDomain *domain, gpointer func, gpointer arg, gboolean threadpool_thread)
> {
> 	MonoThread *thread;
> 	HANDLE thread_handle;
>@@ -637,12 +637,20 @@
> 
> 	thread->synch_cs = g_new0 (CRITICAL_SECTION, 1);
> 	InitializeCriticalSection (thread->synch_cs);
>-						  
>+
>+	thread->threadpool_thread = threadpool_thread;
>+
> 	handle_store(thread);
> 
> 	ResumeThread (thread_handle);
> }
> 
>+void
>+mono_thread_create (MonoDomain *domain, gpointer func, gpointer arg)
>+{
>+	mono_thread_create_internal (domain, func, arg, FALSE);
>+}
>+
> /*
>  * mono_thread_get_stack_bounds:
>  *
>@@ -890,6 +898,7 @@
> 
> 	DeleteCriticalSection (this->synch_cs);
> 	g_free (this->synch_cs);
>+	this->synch_cs = NULL;
> }
> 
> static void mono_thread_start (MonoThread *thread)
>Index: metadata/threadpool.c
>===================================================================
>--- metadata/threadpool.c	(revision 89087)
>+++ metadata/threadpool.c	(working copy)
>@@ -235,7 +235,6 @@
> 	MonoDomain *domain;
> 	MonoThread *thread;
> 	thread = mono_thread_current ();
>-	thread->threadpool_thread = TRUE;
> 	ves_icall_System_Threading_Thread_SetState (thread, ThreadState_Background);
> 
> 	for (;;) {
>@@ -324,7 +323,7 @@
> 		InterlockedIncrement (&busy_io_worker_threads);
> 		InterlockedIncrement (&io_worker_threads);
> 		domain = ((ares) ? ((MonoObject *) ares)->vtable->domain : mono_domain_get ());
>-		mono_thread_create (mono_get_root_domain (), async_invoke_io_thread, ares);
>+		mono_thread_create_internal (mono_get_root_domain (), async_invoke_io_thread, ares, TRUE);
> 	} else {
> 		append_job (&io_queue_lock, &async_io_queue, (MonoObject*)ares);
> 		ReleaseSemaphore (io_job_added, 1, NULL);
>@@ -396,7 +395,6 @@
> 	MonoThread *thread;
> 
> 	thread = mono_thread_current ();
>-	thread->threadpool_thread = TRUE;
> 	ves_icall_System_Threading_Thread_SetState (thread, ThreadState_Background);
> 
> 	allocated = INITIAL_POLLFD_SIZE;
>@@ -766,11 +764,11 @@
> 	g_assert (io_job_added != NULL);
> 	InitializeCriticalSection (&io_queue_lock);
> 	if (data->epoll_disabled) {
>-		mono_thread_create (mono_get_root_domain (), socket_io_poll_main, data);
>+		mono_thread_create_internal (mono_get_root_domain (), socket_io_poll_main, data, TRUE);
> 	}
> #ifdef HAVE_EPOLL
> 	else {
>-		mono_thread_create (mono_get_root_domain (), socket_io_epoll_main, data);
>+		mono_thread_create_internal (mono_get_root_domain (), socket_io_epoll_main, data, TRUE);
> 	}
> #endif
> 	InterlockedCompareExchange (&data->inited, 1, 0);
>@@ -1053,7 +1051,7 @@
> 	    worker < mono_max_worker_threads) {
> 		InterlockedIncrement (&mono_worker_threads);
> 		InterlockedIncrement (&busy_worker_threads);
>-		mono_thread_create (mono_get_root_domain (), async_invoke_thread, ares);
>+		mono_thread_create_internal (mono_get_root_domain (), async_invoke_thread, ares, TRUE);
> 	} else {
> 		append_job (&mono_delegate_section, &async_call_queue, (MonoObject*)ares);
> 		ReleaseSemaphore (job_added, 1, NULL);
>Index: metadata/threads-types.h
>===================================================================
>--- metadata/threads-types.h	(revision 89087)
>+++ metadata/threads-types.h	(working copy)
>@@ -42,6 +42,8 @@
> #define SPECIAL_STATIC_THREAD 1
> #define SPECIAL_STATIC_CONTEXT 2
> 
>+extern void mono_thread_create_internal (MonoDomain *domain, gpointer func, gpointer arg, gboolean threadpool_thread) MONO_INTERNAL;
>+
> extern HANDLE ves_icall_System_Threading_Thread_Thread_internal(MonoThread *this_obj, MonoObject *start) MONO_INTERNAL;
> extern void ves_icall_System_Threading_Thread_Thread_init(MonoThread *this_obj) MONO_INTERNAL;
> extern void ves_icall_System_Threading_Thread_Thread_free_internal(MonoThread *this_obj, HANDLE thread) MONO_INTERNAL;
>Index: metadata/gc.c
>===================================================================
>--- metadata/gc.c	(revision 89087)
>+++ metadata/gc.c	(working copy)
>@@ -41,6 +41,7 @@
> static CRITICAL_SECTION finalizer_mutex;
> 
> static GSList *domains_to_finalize= NULL;
>+static GSList *threads_to_finalize = NULL;
> 
> static MonoThread *gc_thread;
> 
>@@ -52,6 +53,12 @@
> static HANDLE thread_started_event;
> #endif
> 
>+static void
>+add_thread_to_finalize (MonoThread *thread)
>+{
>+	threads_to_finalize = g_slist_append (threads_to_finalize, thread);
>+}
>+
> /* 
>  * 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...
>@@ -79,11 +86,21 @@
> 	/* make sure the finalizer is not called again if the object is resurrected */
> 	object_register_finalizer (obj, NULL);
> 
>-	if (o->vtable->klass == mono_get_thread_class ())
>-		if (mono_gc_is_finalizer_thread ((MonoThread*)o))
>+	if (o->vtable->klass == mono_get_thread_class ()) {
>+		MonoThread *t = (MonoThread*)o;
>+
>+		if (mono_gc_is_finalizer_thread (t))
> 			/* Avoid finalizing ourselves */
> 			return;
> 
>+		if (t->threadpool_thread) {
>+			/* Don't finalize threadpool threads - they're
>+			   finalized when the threadpool shuts down. */
>+			add_thread_to_finalize (t);
>+			return;
>+		}
>+	}
>+
> 	/* speedup later... and use a timeout */
> 	/* g_print ("Finalize run on %p %s.%s\n", o, mono_object_class (o)->name_space, mono_object_class (o)->name); */
> 
>@@ -119,6 +136,22 @@
> 	}
> }
> 
>+void
>+mono_gc_finalize_threadpool_threads (void)
>+{
>+	while (threads_to_finalize) {
>+		MonoThread *thread = threads_to_finalize->data;
>+
>+		/* Force finalization of the thread. */
>+		thread->threadpool_thread = FALSE;
>+		mono_object_register_finalizer ((MonoObject*)thread);
>+
>+		run_finalize (thread, NULL);
>+
>+		threads_to_finalize = g_slist_remove (threads_to_finalize, thread);
>+	}
>+}
>+
> gpointer
> mono_gc_out_of_memory (size_t size)
> {
>Index: mini/mini.c
>===================================================================
>--- mini/mini.c	(revision 89092)
>+++ mini/mini.c	(working copy)
>@@ -12509,7 +12509,10 @@
> 	 * fully working (mono_domain_finalize may invoke managed finalizers
> 	 * and mono_runtime_cleanup will wait for other threads to finish).
> 	 */
>-	mono_domain_finalize (domain, 2000);
>+	if (mono_domain_finalize (domain, 2000) && domain == mono_get_root_domain ()) {
>+		mono_thread_pool_cleanup ();
>+		mono_gc_finalize_threadpool_threads ();
>+	}
> 
> 	/* This accesses metadata so needs to be called before runtime shutdown */
> 	print_jit_stats ();

Actions: View | Diff

Attachments on bug 337383: 182611 | 182687