[io-layer] Remove INFINITE

diff --git a/mono/io-layer/wait.h b/mono/io-layer/wait.h
index b470c2d6f2323957a7fe622adc511c20beded5fa..caa96eb9e2248842ea28854b62db06b3c3d41e16 100644 (file)
--- a/mono/io-layer/wait.h
+++ b/mono/io-layer/wait.h
@@ -15,8 +15,6 @@
 
 G_BEGIN_DECLS
 
-#define INFINITE               0xFFFFFFFF
-
 #define WAIT_FAILED            0xFFFFFFFF
 #define WAIT_OBJECT_0          ((STATUS_WAIT_0) +0)
 #define WAIT_ABANDONED         ((STATUS_ABANDONED_WAIT_0) +0)

diff --git a/mono/metadata/appdomain.c b/mono/metadata/appdomain.c
index 82a0b9e881acf41512407a20f07d2387c61ca636..7f62f1ad5562d30504f3deac4a237ba52c0ea3eb 100644 (file)
--- a/mono/metadata/appdomain.c
+++ b/mono/metadata/appdomain.c
@@ -2582,7 +2582,7 @@ mono_domain_try_unload (MonoDomain *domain, MonoObject **exc)
                return;
 
        /* Wait for the thread */       
-       while (!thread_data->done && guarded_wait (thread_handle, INFINITE, TRUE) == MONO_THREAD_INFO_WAIT_RET_ALERTED) {
+       while (!thread_data->done && guarded_wait (thread_handle, MONO_INFINITE_WAIT, TRUE) == MONO_THREAD_INFO_WAIT_RET_ALERTED) {
                if (mono_thread_internal_has_appdomain_ref (mono_thread_internal_current (), domain) && (mono_thread_interruption_requested ())) {
                        /* The unload thread tries to abort us */
                        /* The icall wrapper will execute the abort */

diff --git a/mono/metadata/gc.c b/mono/metadata/gc.c
index e66b4da35a2b97c6ae48945d7f18dc5325ee0fc3..53cce47edadcfc59778f208bb9c529734edc77fc 100644 (file)
--- a/mono/metadata/gc.c
+++ b/mono/metadata/gc.c
@@ -494,14 +494,14 @@ mono_domain_finalize (MonoDomain *domain, guint32 timeout)
        mono_gc_finalize_notify ();
 
        if (timeout == -1)
-               timeout = INFINITE;
-       if (timeout != INFINITE)
+               timeout = MONO_INFINITE_WAIT;
+       if (timeout != MONO_INFINITE_WAIT)
                start = mono_msec_ticks ();
 
        ret = TRUE;
 
        for (;;) {
-               if (timeout == INFINITE) {
+               if (timeout == MONO_INFINITE_WAIT) {
                        res = mono_coop_sem_wait (&req->done, MONO_SEM_FLAGS_ALERTABLE);
                } else {
                        gint64 elapsed = mono_msec_ticks () - start;
@@ -652,7 +652,7 @@ ves_icall_System_GC_WaitForPendingFinalizers (void)
        pending_done = FALSE;
        mono_gc_finalize_notify ();
        while (!pending_done) {
-               coop_cond_timedwait_alertable (&pending_done_cond, &pending_done_mutex, INFINITE, &alerted);
+               coop_cond_timedwait_alertable (&pending_done_cond, &pending_done_mutex, MONO_INFINITE_WAIT, &alerted);
                if (alerted)
                        break;
        }
@@ -1062,7 +1062,7 @@ mono_gc_cleanup (void)
 
 
                        /* Wait for the thread to actually exit */
-                       ret = guarded_wait (gc_thread->handle, INFINITE, TRUE);
+                       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));

diff --git a/mono/metadata/monitor.c b/mono/metadata/monitor.c
index f11c9589b82fbcc5e629b281b71ecd9085426aff..02a5ef6825d946b701c84d929b7041a44315898b 100644 (file)
--- a/mono/metadata/monitor.c
+++ b/mono/metadata/monitor.c
@@ -868,7 +868,7 @@ retry_contended:
                }
        }
 
-       if (ms != INFINITE) {
+       if (ms != MONO_INFINITE_WAIT) {
                then = mono_msec_ticks ();
        }
        waitms = ms;
@@ -919,7 +919,7 @@ done_waiting:
                 * allow_interruption is FALSE to avoid hangs at shutdown.
                 */
                if (!mono_thread_test_state (mono_thread_internal_current (), (MonoThreadState)(ThreadState_StopRequested | ThreadState_SuspendRequested | ThreadState_AbortRequested))) {
-                       if (ms != INFINITE) {
+                       if (ms != MONO_INFINITE_WAIT) {
                                now = mono_msec_ticks ();
 
                                /* it should not overflow before ~30k years */
@@ -1032,7 +1032,7 @@ mono_monitor_enter (MonoObject *obj)
         * it will return NULL meaning we can't be aborted right now. Once that happens we switch to non-alertable.
         */
        do {
-               res = mono_monitor_try_enter_internal (obj, INFINITE, allow_interruption);
+               res = mono_monitor_try_enter_internal (obj, MONO_INFINITE_WAIT, allow_interruption);
                /*This means we got interrupted during the wait and didn't got the monitor.*/
                if (res == -1) {
                        MonoException *exc = mono_thread_interruption_checkpoint ();
@@ -1160,7 +1160,7 @@ mono_monitor_enter_v4 (MonoObject *obj, char *lock_taken)
                return;
        }
 
-       ves_icall_System_Threading_Monitor_Monitor_try_enter_with_atomic_var (obj, INFINITE, lock_taken);
+       ves_icall_System_Threading_Monitor_Monitor_try_enter_with_atomic_var (obj, MONO_INFINITE_WAIT, lock_taken);
 }
 
 /*
@@ -1364,7 +1364,7 @@ ves_icall_System_Threading_Monitor_Monitor_wait (MonoObject *obj, guint32 ms)
 
        /* Regain the lock with the previous nest count */
        do {
-               regain = mono_monitor_try_enter_inflated (obj, INFINITE, TRUE, id);
+               regain = mono_monitor_try_enter_inflated (obj, MONO_INFINITE_WAIT, TRUE, id);
                /* We must regain the lock before handling interruption requests */
        } while (regain == -1);
 

diff --git a/mono/metadata/threadpool-ms.c b/mono/metadata/threadpool-ms.c
index 43444211fe408992915b70e36495a3c6dabe13e5..945dc80843d715a8eb14010000359b5b65984c28 100644 (file)
--- a/mono/metadata/threadpool-ms.c
+++ b/mono/metadata/threadpool-ms.c
@@ -1446,7 +1446,7 @@ mono_threadpool_ms_end_invoke (MonoAsyncResult *ares, MonoArray **out_args, Mono
 #ifdef HOST_WIN32
                WaitForSingleObjectEx (wait_event, INFINITE, TRUE);
 #else
-               mono_w32handle_wait_one (wait_event, INFINITE, TRUE);
+               mono_w32handle_wait_one (wait_event, MONO_INFINITE_WAIT, TRUE);
 #endif
                MONO_EXIT_GC_SAFE;
        }

diff --git a/mono/metadata/threads.c b/mono/metadata/threads.c
index a779e4a07a416141300eedff89610d0f0d0297fb..7b453f78de3061eb811e2372288e6a4d6a5a6d37 100644 (file)
--- a/mono/metadata/threads.c
+++ b/mono/metadata/threads.c
@@ -1325,8 +1325,8 @@ ves_icall_System_Threading_Thread_Sleep_internal(gint32 ms)
                        if (exc) {
                                mono_raise_exception (exc);
                        } else {
-                               // FIXME: !INFINITE
-                               if (ms != INFINITE)
+                               // FIXME: !MONO_INFINITE_WAIT
+                               if (ms != MONO_INFINITE_WAIT)
                                        break;
                        }
                } else {
@@ -1638,7 +1638,7 @@ ves_icall_System_Threading_Thread_Join_internal(MonoThread *this_obj, int ms)
        UNLOCK_THREAD (thread);
 
        if(ms== -1) {
-               ms=INFINITE;
+               ms=MONO_INFINITE_WAIT;
        }
        THREAD_DEBUG (g_message ("%s: joining thread handle %p, %d ms", __func__, handle, ms));
        
@@ -1755,7 +1755,7 @@ gint32 ves_icall_System_Threading_WaitHandle_WaitAll_internal(MonoArray *mono_ha
        }
        
        if(ms== -1) {
-               ms=INFINITE;
+               ms=MONO_INFINITE_WAIT;
        }
 
        mono_thread_set_state (thread, ThreadState_WaitSleepJoin);
@@ -1795,7 +1795,7 @@ gint32 ves_icall_System_Threading_WaitHandle_WaitAny_internal(MonoArray *mono_ha
        }
        
        if(ms== -1) {
-               ms=INFINITE;
+               ms=MONO_INFINITE_WAIT;
        }
 
        mono_thread_set_state (thread, ThreadState_WaitSleepJoin);
@@ -1820,7 +1820,7 @@ gint32 ves_icall_System_Threading_WaitHandle_WaitOne_internal(HANDLE handle, gin
        THREAD_WAIT_DEBUG (g_message ("%s: (%"G_GSIZE_FORMAT") waiting for %p, %d ms", __func__, mono_native_thread_id_get (), handle, ms));
        
        if(ms== -1) {
-               ms=INFINITE;
+               ms=MONO_INFINITE_WAIT;
        }
        
        if (mono_thread_current_check_pending_interrupt ())
@@ -1843,7 +1843,7 @@ ves_icall_System_Threading_WaitHandle_SignalAndWait_Internal (HANDLE toSignal, H
        MonoInternalThread *thread = mono_thread_internal_current ();
 
        if (ms == -1)
-               ms = INFINITE;
+               ms = MONO_INFINITE_WAIT;
 
        if (mono_thread_current_check_pending_interrupt ())
                return map_native_wait_result_to_managed (MONO_W32HANDLE_WAIT_RET_FAILED, 0);
@@ -3161,7 +3161,7 @@ void mono_thread_manage (void)
                mono_threads_unlock ();
                if (wait->num > 0)
                        /* Something to wait for */
-                       wait_for_tids (wait, INFINITE, TRUE);
+                       wait_for_tids (wait, MONO_INFINITE_WAIT, TRUE);
                THREAD_DEBUG (g_message ("%s: I have %d threads after waiting.", __func__, wait->num));
        } while(wait->num>0);
 
@@ -3189,7 +3189,7 @@ void mono_thread_manage (void)
                THREAD_DEBUG (g_message ("%s: wait->num is now %d", __func__, wait->num));
                if (wait->num > 0) {
                        /* Something to wait for */
-                       wait_for_tids (wait, INFINITE, FALSE);
+                       wait_for_tids (wait, MONO_INFINITE_WAIT, FALSE);
                }
        } while (wait->num > 0);
        

diff --git a/mono/metadata/w32handle.c b/mono/metadata/w32handle.c
index 78f5b83d2b26114ab75feb787179d31a45f811ba..88895e7fb5e3624bdd1db59faaf69f1a3895f2ab 100644 (file)
--- a/mono/metadata/w32handle.c
+++ b/mono/metadata/w32handle.c
@@ -29,8 +29,6 @@
 /* must be a power of 2 */
 #define HANDLE_PER_SLOT        (256)
 
-#define INFINITE 0xFFFFFFFF
-
 typedef struct {
        MonoW32HandleType type;
        guint ref;
@@ -1137,7 +1135,7 @@ mono_w32handle_wait_one (gpointer handle, guint32 timeout, gboolean alertable)
                }
        }
 
-       if (timeout != INFINITE)
+       if (timeout != MONO_INFINITE_WAIT)
                start = mono_msec_ticks ();
 
        for (;;) {
@@ -1153,8 +1151,8 @@ mono_w32handle_wait_one (gpointer handle, guint32 timeout, gboolean alertable)
 
                mono_w32handle_ops_prewait (handle);
 
-               if (timeout == INFINITE) {
-                       waited = mono_w32handle_timedwait_signal_handle (handle, INFINITE, FALSE, alertable ? &alerted : NULL);
+               if (timeout == MONO_INFINITE_WAIT) {
+                       waited = mono_w32handle_timedwait_signal_handle (handle, MONO_INFINITE_WAIT, FALSE, alertable ? &alerted : NULL);
                } else {
                        gint64 elapsed;
 
@@ -1240,7 +1238,7 @@ mono_w32handle_wait_multiple (gpointer *handles, gsize nhandles, gboolean waital
                }
        }
 
-       if (timeout != INFINITE)
+       if (timeout != MONO_INFINITE_WAIT)
                start = mono_msec_ticks ();
 
        for (i = 0; i < nhandles; ++i) {
@@ -1324,8 +1322,8 @@ mono_w32handle_wait_multiple (gpointer *handles, gsize nhandles, gboolean waital
                waited = 0;
 
                if (!signalled) {
-                       if (timeout == INFINITE) {
-                               waited = mono_w32handle_timedwait_signal (INFINITE, poll, alertable ? &alerted : NULL);
+                       if (timeout == MONO_INFINITE_WAIT) {
+                               waited = mono_w32handle_timedwait_signal (MONO_INFINITE_WAIT, poll, alertable ? &alerted : NULL);
                        } else {
                                gint64 elapsed;
 
@@ -1404,7 +1402,7 @@ mono_w32handle_signal_and_wait (gpointer signal_handle, gpointer wait_handle, gu
                }
        }
 
-       if (timeout != INFINITE)
+       if (timeout != MONO_INFINITE_WAIT)
                start = mono_msec_ticks ();
 
        for (;;) {
@@ -1420,8 +1418,8 @@ mono_w32handle_signal_and_wait (gpointer signal_handle, gpointer wait_handle, gu
 
                mono_w32handle_ops_prewait (wait_handle);
 
-               if (timeout == INFINITE) {
-                       waited = mono_w32handle_timedwait_signal_handle (wait_handle, INFINITE, FALSE, alertable ? &alerted : NULL);
+               if (timeout == MONO_INFINITE_WAIT) {
+                       waited = mono_w32handle_timedwait_signal_handle (wait_handle, MONO_INFINITE_WAIT, FALSE, alertable ? &alerted : NULL);
                } else {
                        gint64 elapsed;
 

diff --git a/mono/metadata/w32handle.h b/mono/metadata/w32handle.h
index 1416bf2479b77125b572d3de91da7222ae885f5e..801e32a3cc87d34553b4022b15961dad6eb87148 100644 (file)
--- a/mono/metadata/w32handle.h
+++ b/mono/metadata/w32handle.h
@@ -15,6 +15,10 @@
 
 #define MONO_W32HANDLE_MAXIMUM_WAIT_OBJECTS 64
 
+#ifndef MONO_INFINITE_WAIT
+#define MONO_INFINITE_WAIT ((guint32) 0xFFFFFFFF)
+#endif
+
 typedef enum {
        MONO_W32HANDLE_UNUSED = 0,
        MONO_W32HANDLE_FILE,

diff --git a/mono/metadata/w32process-unix.c b/mono/metadata/w32process-unix.c
index 0b387e6d2a48a617e3376fc15bc8acc38f7bd7a1..7ae000b1bd56162c07511c0381adf0a737b6bc37 100644 (file)
--- a/mono/metadata/w32process-unix.c
+++ b/mono/metadata/w32process-unix.c
@@ -287,7 +287,7 @@ process_wait (gpointer handle, guint32 timeout, gboolean *alerted)
        now = start;
 
        while (1) {
-               if (timeout != INFINITE) {
+               if (timeout != MONO_INFINITE_WAIT) {
                        mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s (%p, %u): waiting on semaphore for %li ms...",
                                __func__, handle, timeout, (long)(timeout - (now - start)));
                        ret = mono_os_sem_timedwait (&mp->exit_sem, (timeout - (now - start)), alerted ? MONO_SEM_FLAGS_ALERTABLE : MONO_SEM_FLAGS_NONE);

diff --git a/mono/mini/aot-compiler.c b/mono/mini/aot-compiler.c
index 3c626c2de1c5d646567312e91394ea6735afa21e..32b0caa88025cf566aeca079c82a0f91973d17b7 100644 (file)
--- a/mono/mini/aot-compiler.c
+++ b/mono/mini/aot-compiler.c
@@ -9925,7 +9925,7 @@ compile_methods (MonoAotCompile *acfg)
                g_free (methods);
 
                for (i = 0; i < threads->len; ++i) {
-                       mono_thread_info_wait_one_handle (g_ptr_array_index (threads, i), INFINITE, FALSE);
+                       mono_thread_info_wait_one_handle (g_ptr_array_index (threads, i), MONO_INFINITE_WAIT, FALSE);
                        mono_threads_close_thread_handle (g_ptr_array_index (threads, i));
                }
        } else {

diff --git a/mono/utils/mono-os-semaphore.h b/mono/utils/mono-os-semaphore.h
index c4bfe620f98edd116b07884e10c0f9b5ecae0922..42d19c403ba179c5b4f51bb498c10bb0e52757f4 100644 (file)
--- a/mono/utils/mono-os-semaphore.h
+++ b/mono/utils/mono-os-semaphore.h
@@ -339,7 +339,7 @@ retry:
 static inline int
 mono_os_sem_wait (MonoSemType *sem, MonoSemFlags flags)
 {
-       return mono_os_sem_timedwait (sem, INFINITE, flags) != 0 ? -1 : 0;
+       return mono_os_sem_timedwait (sem, MONO_INFINITE_WAIT, flags) != 0 ? -1 : 0;
 }
 
 static inline void

diff --git a/mono/utils/mono-threads.c b/mono/utils/mono-threads.c
index cabfa0b3856281372e4c3c7083df0373edb0bb55..033e4670851677870a93ce842b1a1c629a2cb79a 100644 (file)
--- a/mono/utils/mono-threads.c
+++ b/mono/utils/mono-threads.c
@@ -1244,12 +1244,12 @@ sleep_interruptable (guint32 ms, gboolean *alerted)
 {
        gint64 now, end;
 
-       g_assert (INFINITE == G_MAXUINT32);
+       g_assert (MONO_INFINITE_WAIT == G_MAXUINT32);
 
        g_assert (alerted);
        *alerted = FALSE;
 
-       if (ms != INFINITE)
+       if (ms != MONO_INFINITE_WAIT)
                end = mono_msec_ticks() + ms;
 
        mono_lazy_initialize (&sleep_init, sleep_initialize);
@@ -1257,7 +1257,7 @@ sleep_interruptable (guint32 ms, gboolean *alerted)
        mono_coop_mutex_lock (&sleep_mutex);
 
        for (;;) {
-               if (ms != INFINITE) {
+               if (ms != MONO_INFINITE_WAIT) {
                        now = mono_msec_ticks();
                        if (now >= end)
                                break;
@@ -1269,7 +1269,7 @@ sleep_interruptable (guint32 ms, gboolean *alerted)
                        return WAIT_IO_COMPLETION;
                }
 
-               if (ms != INFINITE)
+               if (ms != MONO_INFINITE_WAIT)
                        mono_coop_cond_timedwait (&sleep_cond, &sleep_mutex, end - now);
                else
                        mono_coop_cond_wait (&sleep_cond, &sleep_mutex);
@@ -1306,7 +1306,7 @@ mono_thread_info_sleep (guint32 ms, gboolean *alerted)
 
        MONO_ENTER_GC_SAFE;
 
-       if (ms == INFINITE) {
+       if (ms == MONO_INFINITE_WAIT) {
                do {
 #ifdef HOST_WIN32
                        Sleep (G_MAXUINT32);

diff --git a/mono/utils/mono-threads.h b/mono/utils/mono-threads.h
index b9ce4f7f43ad500d027678304341230db9218b57..52ac93337b9973df31a097be8208bc828a42b1e0 100644 (file)
--- a/mono/utils/mono-threads.h
+++ b/mono/utils/mono-threads.h
@@ -66,6 +66,10 @@ typedef gsize (*MonoThreadStart)(gpointer);
 
 #endif /* #ifdef HOST_WIN32 */
 
+#ifndef MONO_INFINITE_WAIT
+#define MONO_INFINITE_WAIT ((guint32) 0xFFFFFFFF)
+#endif
+
 typedef struct {
        MonoRefCount ref;
        MonoOSEvent event;