[threads] Remove dead field cached_culture_info (#4410)

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

diff --git a/mono/metadata/threads.c b/mono/metadata/threads.c
index 3461f81e325c6dde6063bb487799a5d24b4baf02..1c47c4445871cb0f65d0ddbe6fe9710b52d870bd 100644 (file)
--- a/mono/metadata/threads.c
+++ b/mono/metadata/threads.c
@@ -29,7 +29,7 @@
 #include <mono/metadata/marshal.h>
 #include <mono/metadata/runtime.h>
 #include <mono/metadata/object-internals.h>
-#include <mono/metadata/mono-debug-debugger.h>
+#include <mono/metadata/debug-internals.h>
 #include <mono/utils/monobitset.h>
 #include <mono/utils/mono-compiler.h>
 #include <mono/utils/mono-mmap.h>
@@ -114,14 +114,6 @@ typedef struct {
        StaticDataFreeList *freelist;
 } StaticDataInfo;
 
-/* Number of cached culture objects in the MonoThread->cached_culture_info array
- * (per-type): we use the first NUM entries for CultureInfo and the last for
- * UICultureInfo. So the size of the array is really NUM_CACHED_CULTURES * 2.
- */
-#define NUM_CACHED_CULTURES 4
-#define CULTURES_START_IDX 0
-#define UICULTURES_START_IDX NUM_CACHED_CULTURES
-
 /* Controls access to the 'threads' hash table */
 static void mono_threads_lock (void);
 static void mono_threads_unlock (void);
@@ -1130,17 +1122,6 @@ mono_thread_detach_internal (MonoInternalThread *thread)
        thread->abort_exc = NULL;
        thread->current_appcontext = NULL;
 
-       /*
-        * This is necessary because otherwise we might have
-        * cross-domain references which will not get cleaned up when
-        * the target domain is unloaded.
-        */
-       if (thread->cached_culture_info) {
-               int i;
-               for (i = 0; i < NUM_CACHED_CULTURES * 2; ++i)
-                       mono_array_set (thread->cached_culture_info, MonoObject*, i, NULL);
-       }
-
        /*
         * thread->synch_cs can be NULL if this was called after
         * ves_icall_System_Threading_InternalThread_Thread_free_internal.
@@ -1231,8 +1212,6 @@ mono_thread_detach_internal (MonoInternalThread *thread)
        if (thread == mono_thread_internal_current ())
                mono_thread_pop_appdomain_ref ();
 
-       thread->cached_culture_info = NULL;
-
        mono_free_static_data (thread->static_data);
        thread->static_data = NULL;
        ref_stack_destroy (thread->appdomain_refs);
@@ -2630,53 +2609,27 @@ is_running_protected_wrapper (void)
        return found;
 }
 
-static gboolean
-request_thread_stop (MonoInternalThread *thread)
+void
+mono_thread_stop (MonoThread *thread)
 {
-       LOCK_THREAD (thread);
+       MonoInternalThread *internal = thread->internal_thread;
 
-       if ((thread->state & ThreadState_StopRequested) != 0 ||
-               (thread->state & ThreadState_Stopped) != 0)
+       LOCK_THREAD (internal);
+
+       if (internal->state & (ThreadState_StopRequested | ThreadState_Stopped))
        {
-               UNLOCK_THREAD (thread);
-               return FALSE;
+               UNLOCK_THREAD (internal);
+               return;
        }
-       
-       /* Make sure the thread is awake */
-       mono_thread_resume (thread);
 
-       thread->state |= ThreadState_StopRequested;
-       thread->state &= ~ThreadState_AbortRequested;
-       
-       UNLOCK_THREAD (thread);
-       return TRUE;
-}
-
-/**
- * mono_thread_internal_stop:
- *
- * Request thread @thread to stop.
- *
- * @thread MUST NOT be the current thread.
- */
-void
-mono_thread_internal_stop (MonoInternalThread *thread)
-{
-       g_assert (thread != mono_thread_internal_current ());
+       /* Make sure the internal is awake */
+       mono_thread_resume (internal);
 
-       if (!request_thread_stop (thread))
-               return;
-       
-       async_abort_internal (thread, TRUE);
-}
+       internal->state |= ThreadState_StopRequested;
+       internal->state &= ~ThreadState_AbortRequested;
 
-void mono_thread_stop (MonoThread *thread)
-{
-       MonoInternalThread *internal = thread->internal_thread;
+       UNLOCK_THREAD (internal);
 
-       if (!request_thread_stop (internal))
-               return;
-       
        if (internal == mono_thread_internal_current ()) {
                MonoError error;
                self_abort_internal (&error);
@@ -3960,39 +3913,6 @@ mono_threads_abort_appdomain_threads (MonoDomain *domain, int timeout)
        return TRUE;
 }
 
-static void
-clear_cached_culture (gpointer key, gpointer value, gpointer user_data)
-{
-       MonoInternalThread *thread = (MonoInternalThread*)value;
-       MonoDomain *domain = (MonoDomain*)user_data;
-       int i;
-
-       /* No locking needed here */
-       /* FIXME: why no locking? writes to the cache are protected with synch_cs above */
-
-       if (thread->cached_culture_info) {
-               for (i = 0; i < NUM_CACHED_CULTURES * 2; ++i) {
-                       MonoObject *obj = mono_array_get (thread->cached_culture_info, MonoObject*, i);
-                       if (obj && obj->vtable->domain == domain)
-                               mono_array_set (thread->cached_culture_info, MonoObject*, i, NULL);
-               }
-       }
-}
-       
-/*
- * mono_threads_clear_cached_culture:
- *
- *   Clear the cached_current_culture from all threads if it is in the
- * given appdomain.
- */
-void
-mono_threads_clear_cached_culture (MonoDomain *domain)
-{
-       mono_threads_lock ();
-       mono_g_hash_table_foreach (threads, clear_cached_culture, domain);
-       mono_threads_unlock ();
-}
-
 /*
  * mono_thread_get_undeniable_exception:
  *