[threadpool] Refactor begin/end invoke runtime support

diff --git a/mono/metadata/console-unix.c b/mono/metadata/console-unix.c
index 022822021400fd160ab63f4d0965ac6421cc25c8..dd64b249703eb62873c90b21d8af5697f375ccc8 100644 (file)
--- a/mono/metadata/console-unix.c
+++ b/mono/metadata/console-unix.c
@@ -225,8 +225,6 @@ do_console_cancel_event (void)
        MonoClass *klass;
        MonoDelegate *load_value;
        MonoMethod *method;
-       MonoMethodMessage *msg;
-       MonoMethod *im;
        MonoVTable *vtable;
 
        /* FIXME: this should likely iterate all the domains, instead */
@@ -252,9 +250,8 @@ do_console_cancel_event (void)
        klass = load_value->object.vtable->klass;
        method = mono_class_get_method_from_name (klass, "BeginInvoke", -1);
        g_assert (method != NULL);
-       im = mono_get_delegate_invoke (method->klass);
-       msg = mono_method_call_message_new (method, NULL, im, NULL, NULL);
-       mono_thread_pool_add ((MonoObject *) load_value, msg, NULL, NULL);
+
+       mono_thread_pool_begin_invoke (domain, (MonoObject*) load_value, method, NULL);
 }
 
 static int need_cancel = FALSE;

diff --git a/mono/metadata/marshal.c b/mono/metadata/marshal.c
index c68f78d2e9de449e582c4fd988db9895cf1e6766..39288f5537423a79ae072a752f6e0b2507ef9eaf 100644 (file)
--- a/mono/metadata/marshal.c
+++ b/mono/metadata/marshal.c
@@ -2055,13 +2055,9 @@ mono_marshal_emit_thread_force_interrupt_checkpoint (MonoMethodBuilder *mb)
 static MonoAsyncResult *
 mono_delegate_begin_invoke (MonoDelegate *delegate, gpointer *params)
 {
-       MonoMethodMessage *msg;
-       MonoDelegate *async_callback;
        MonoMulticastDelegate *mcast_delegate;
-       MonoObject *state;
-       MonoMethod *im;
        MonoClass *klass;
-       MonoMethod *method = NULL, *method2 = NULL;
+       MonoMethod *method;
 
        g_assert (delegate);
        mcast_delegate = (MonoMulticastDelegate *) delegate;
@@ -2077,6 +2073,9 @@ mono_delegate_begin_invoke (MonoDelegate *delegate, gpointer *params)
                        /* If the target is a proxy, make a direct call. Is proxy's work
                        // to make the call asynchronous.
                        */
+                       MonoMethodMessage *msg;
+                       MonoDelegate *async_callback;
+                       MonoObject *state;
                        MonoAsyncResult *ares;
                        MonoObject *exc;
                        MonoArray *out_args;
@@ -2100,16 +2099,12 @@ mono_delegate_begin_invoke (MonoDelegate *delegate, gpointer *params)
 
        klass = delegate->object.vtable->klass;
 
-       method = mono_get_delegate_invoke (klass);
-       method2 = mono_class_get_method_from_name (klass, "BeginInvoke", -1);
-       if (method2)
-               method = method2;
-       g_assert (method != NULL);
-
-       im = mono_get_delegate_invoke (method->klass);
-       msg = mono_method_call_message_new (method, params, im, &async_callback, &state);
+       method = mono_class_get_method_from_name (klass, "BeginInvoke", -1);
+       if (!method)
+               method = mono_get_delegate_invoke (klass);
+       g_assert (method);
 
-       return mono_thread_pool_add ((MonoObject *)delegate, msg, async_callback, state);
+       return mono_thread_pool_begin_invoke (mono_domain_get (), (MonoObject*) delegate, method, params);
 }
 
 #ifndef DISABLE_JIT
@@ -2824,7 +2819,7 @@ mono_delegate_end_invoke (MonoDelegate *delegate, gpointer *params)
        } else
 #endif
        {
-               res = mono_thread_pool_finish (ares, &out_args, &exc);
+               res = mono_thread_pool_end_invoke (ares, &out_args, &exc);
        }
 
        if (exc) {

diff --git a/mono/metadata/threadpool-ms.c b/mono/metadata/threadpool-ms.c
index e4c7e6d50f680eee24f95715b273264f000c574d..3bc2507a28ec6c2ba6032afb261692fa8de0d0bb 100644 (file)
--- a/mono/metadata/threadpool-ms.c
+++ b/mono/metadata/threadpool-ms.c
@@ -1229,12 +1229,14 @@ mono_threadpool_ms_cleanup (void)
 }
 
 MonoAsyncResult *
-mono_threadpool_ms_add (MonoObject *target, MonoMethodMessage *msg, MonoDelegate *async_callback, MonoObject *state)
+mono_threadpool_ms_begin_invoke (MonoDomain *domain, MonoObject *target, MonoMethod *method, gpointer *params)
 {
        static MonoClass *async_call_klass = NULL;
-       MonoDomain *domain;
-       MonoAsyncResult *ares;
-       MonoAsyncCall *ac;
+       MonoMethodMessage *message;
+       MonoAsyncResult *async_result;
+       MonoAsyncCall *async_call;
+       MonoDelegate *async_callback = NULL;
+       MonoObject *state = NULL;
 
        if (!async_call_klass)
                async_call_klass = mono_class_from_name (mono_defaults.corlib, "System", "MonoAsyncCall");
@@ -1242,31 +1244,32 @@ mono_threadpool_ms_add (MonoObject *target, MonoMethodMessage *msg, MonoDelegate
 
        ensure_initialized (NULL);
 
-       domain = mono_domain_get ();
+       message = mono_method_call_message_new (method, params, mono_get_delegate_invoke (method->klass), (params != NULL) ? (&async_callback) : NULL, (params != NULL) ? (&state) : NULL);
 
-       ac = (MonoAsyncCall*) mono_object_new (domain, async_call_klass);
-       MONO_OBJECT_SETREF (ac, msg, msg);
-       MONO_OBJECT_SETREF (ac, state, state);
+       async_call = (MonoAsyncCall*) mono_object_new (domain, async_call_klass);
+       MONO_OBJECT_SETREF (async_call, msg, message);
+       MONO_OBJECT_SETREF (async_call, state, state);
 
        if (async_callback) {
-               MONO_OBJECT_SETREF (ac, cb_method, mono_get_delegate_invoke (((MonoObject*) async_callback)->vtable->klass));
-               MONO_OBJECT_SETREF (ac, cb_target, async_callback);
+               MONO_OBJECT_SETREF (async_call, cb_method, mono_get_delegate_invoke (((MonoObject*) async_callback)->vtable->klass));
+               MONO_OBJECT_SETREF (async_call, cb_target, async_callback);
        }
 
-       ares = mono_async_result_new (domain, NULL, ac->state, NULL, (MonoObject*) ac);
-       MONO_OBJECT_SETREF (ares, async_delegate, target);
+       async_result = mono_async_result_new (domain, NULL, async_call->state, NULL, (MonoObject*) async_call);
+       MONO_OBJECT_SETREF (async_result, async_delegate, target);
 
 #ifndef DISABLE_SOCKETS
        if (mono_threadpool_ms_is_io (target, state))
-               return mono_threadpool_ms_io_add (ares, (MonoSocketAsyncResult*) state);
+               return mono_threadpool_ms_io_add (async_result, (MonoSocketAsyncResult*) state);
 #endif
 
-       mono_threadpool_ms_enqueue_work_item (domain, (MonoObject*) ares);
-       return ares;
+       mono_threadpool_ms_enqueue_work_item (domain, (MonoObject*) async_result);
+
+       return async_result;
 }
 
 MonoObject *
-mono_threadpool_ms_finish (MonoAsyncResult *ares, MonoArray **out_args, MonoObject **exc)
+mono_threadpool_ms_end_invoke (MonoAsyncResult *ares, MonoArray **out_args, MonoObject **exc)
 {
        MonoAsyncCall *ac;
 

diff --git a/mono/metadata/threadpool-ms.h b/mono/metadata/threadpool-ms.h
index cca595fcf38a71f203c10c69afe9057827eab52f..9419d5c18b8590bdc869c86d79b8c7c8ea00771f 100644 (file)
--- a/mono/metadata/threadpool-ms.h
+++ b/mono/metadata/threadpool-ms.h
@@ -34,9 +34,9 @@ void
 mono_threadpool_ms_cleanup (void);
 
 MonoAsyncResult *
-mono_threadpool_ms_add (MonoObject *target, MonoMethodMessage *msg, MonoDelegate *async_callback, MonoObject *state);
+mono_threadpool_ms_begin_invoke (MonoDomain *domain, MonoObject *target, MonoMethod *method, gpointer *params);
 MonoObject *
-mono_threadpool_ms_finish (MonoAsyncResult *ares, MonoArray **out_args, MonoObject **exc);
+mono_threadpool_ms_end_invoke (MonoAsyncResult *ares, MonoArray **out_args, MonoObject **exc);
 
 gboolean
 mono_threadpool_ms_remove_domain_jobs (MonoDomain *domain, int timeout);

diff --git a/mono/metadata/threadpool.c b/mono/metadata/threadpool.c
index 6f1226f55af69d46a18ec0c0a1d5bf336b4a1750..c901d401acad6bd05f00ea1c750fab9114803b57 100644 (file)
--- a/mono/metadata/threadpool.c
+++ b/mono/metadata/threadpool.c
@@ -1003,48 +1003,49 @@ icall_append_io_job (MonoObject *target, MonoSocketAsyncResult *state)
 }
 
 MonoAsyncResult *
-mono_thread_pool_add (MonoObject *target, MonoMethodMessage *msg, MonoDelegate *async_callback,
-                     MonoObject *state)
+mono_thread_pool_begin_invoke (MonoDomain *domain, MonoObject *target, MonoMethod *method, gpointer *params)
 {
-       MonoDomain *domain;
-       MonoAsyncResult *ares;
-       MonoAsyncCall *ac;
+       MonoMethodMessage *message;
+       MonoAsyncResult *async_result;
+       MonoAsyncCall *async_call;
+       MonoDelegate *async_callback = NULL;
+       MonoObject *state = NULL;
 
        if (use_ms_threadpool ())
-               return mono_threadpool_ms_add (target, msg, async_callback, state);
+               return mono_threadpool_ms_begin_invoke (domain, target, method, params);
 
-       domain = mono_domain_get ();
+       message = mono_method_call_message_new (method, params, mono_get_delegate_invoke (method->klass), (params != NULL) ? (&async_callback) : NULL, (params != NULL) ? (&state) : NULL);
 
-       ac = (MonoAsyncCall*)mono_object_new (domain, async_call_klass);
-       MONO_OBJECT_SETREF (ac, msg, msg);
-       MONO_OBJECT_SETREF (ac, state, state);
+       async_call = (MonoAsyncCall*)mono_object_new (domain, async_call_klass);
+       MONO_OBJECT_SETREF (async_call, msg, message);
+       MONO_OBJECT_SETREF (async_call, state, state);
 
        if (async_callback) {
-               ac->cb_method = mono_get_delegate_invoke (((MonoObject *)async_callback)->vtable->klass);
-               MONO_OBJECT_SETREF (ac, cb_target, async_callback);
+               async_call->cb_method = mono_get_delegate_invoke (((MonoObject*) async_callback)->vtable->klass);
+               MONO_OBJECT_SETREF (async_call, cb_target, async_callback);
        }
 
-       ares = mono_async_result_new (domain, NULL, ac->state, NULL, (MonoObject*)ac);
-       MONO_OBJECT_SETREF (ares, async_delegate, target);
+       async_result = mono_async_result_new (domain, NULL, async_call->state, NULL, (MonoObject*) async_call);
+       MONO_OBJECT_SETREF (async_result, async_delegate, target);
 
 #ifndef DISABLE_SOCKETS
        if (socket_io_filter (target, state)) {
-               socket_io_add (ares, (MonoSocketAsyncResult *) state);
-               return ares;
+               socket_io_add (async_result, (MonoSocketAsyncResult *) state);
+               return async_result;
        }
 #endif
-       threadpool_append_job (&async_tp, (MonoObject *) ares);
-       return ares;
+       threadpool_append_job (&async_tp, (MonoObject *) async_result);
+       return async_result;
 }
 
 MonoObject *
-mono_thread_pool_finish (MonoAsyncResult *ares, MonoArray **out_args, MonoObject **exc)
+mono_thread_pool_end_invoke (MonoAsyncResult *ares, MonoArray **out_args, MonoObject **exc)
 {
        MonoAsyncCall *ac;
        HANDLE wait_event;
 
        if (use_ms_threadpool ()) {
-               return mono_threadpool_ms_finish (ares, out_args, exc);
+               return mono_threadpool_ms_end_invoke (ares, out_args, exc);
        }
 
        *exc = NULL;

diff --git a/mono/metadata/threadpool.h b/mono/metadata/threadpool.h
index 2c9249e87ca3cb7d6d5490360309739b36dfa05b..eab5e1cb010f64dab4ee81f1c9d587768dd9fac0 100644 (file)
--- a/mono/metadata/threadpool.h
+++ b/mono/metadata/threadpool.h
@@ -11,13 +11,12 @@ void mono_thread_pool_init_tls (void);
 
 void icall_append_job (MonoObject *ar);
 void icall_append_io_job (MonoObject *target, MonoSocketAsyncResult *state);
+
 MonoAsyncResult *
-mono_thread_pool_add     (MonoObject *target, MonoMethodMessage *msg, 
-                         MonoDelegate *async_callback, MonoObject *state);
+mono_thread_pool_begin_invoke (MonoDomain *domain, MonoObject *target, MonoMethod *method, gpointer *params);
 
 MonoObject *
-mono_thread_pool_finish (MonoAsyncResult *ares, MonoArray **out_args, 
-                        MonoObject **exc);
+mono_thread_pool_end_invoke (MonoAsyncResult *ares, MonoArray **out_args, MonoObject **exc);
 
 void mono_thread_pool_cleanup (void);