GitLab

Duncan Coutts pushed to branch wip/io-manager-deadlock-detection at Glasgow Haskell Compiler / GHC

Commits:

e3f31b36

by Duncan Coutts at 2026-09-04T10:51:13+01:00

Add idle GC mode for !HAVE_PREEMPTION

We have to do idle GC (and thus deadlock detection) differently when we
do not have the ticker and the ability to interrupt the I/O manager
when it's blocking.

6 changed files:

rts/IdleGC.c
rts/IdleGC.h
rts/Timer.c
rts/posix/Poll.c
rts/posix/Timeout.c
rts/posix/Timeout.h

Changes:

rts/IdleGC.c

@@ -55,6 +55,8 @@
   automatic GCs.  Both timers must expire before an automatic GC is triggered.
   See issue #11134 for additional detail.
++
 + See also Note [Deadlock detection].
  */
@@ -113,6 +115,8 @@ bool isIdleGcPending(void)
      return (getRecentActivity() == ACTIVITY_INACTIVE);
+ }
 +#if defined(THREADED_IDLEGC)
++
  /* - countdown for minimum idle time before we start a GC (set by -I) */
  static int idle_ticks_to_gc = 0;
@@ -170,6 +174,47 @@ void handleIdleGcTick(void)
+   }
+ }
 +#else // !defined(THREADED_IDLEGC)
++
 +/* Note [Idle GC without preemption]
 +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
++
 +On non-threaded platforms without pre-emption, e.g. wasm, we have to use a
 +different design for scheduling idle GC (and thus deadlock detection, see
 +Note [Deadlock detection]).
++
 +Instead of a ticker thread that interrupts the idle capability after some delay,
 +we arrange for the I/O manager to only sleep for a maximum of the idle GC delay
 +time. The function getNextIdleGcDelayTime() returns this time, accounting for
 +the interIdleGCWait.
++
 +Then if that timeout is reached the I/O manager calls notifyIdleGcIdle(),
 +which schedules an idle GC (by seting the recent activity state). The I/O
 +manager must then behave as if it had been interrupted (as happens with the
 +threaded idle GC design).
 +*/
++
 +static Time last_idle_gc_time = 0;
++
 +Time getNextIdleGcDelayTime()
 +{
 +    Time now   = getProcessElapsedTime();
 +    Time delay =
 +        stg_max (last_idle_gc_time + RtsFlags.GcFlags.interIdleGCWait - now,
 +                 RtsFlags.GcFlags.idleGCDelayTime);
 +    ASSERT(delay >= 0);
 +    return delay;
 +}
++
 +void notifyIdleGcIdle(bool deadlocked)
 +{
 +    if (RtsFlags.GcFlags.doIdleGC || deadlocked) {
 +        setRecentActivity(ACTIVITY_INACTIVE);
 +    }
 +}
++
 +#endif // defined(THREADED_IDLEGC)
++
  void notifyIdleGcActive(void)
+ {
      switch (getRecentActivity())
@@ -209,6 +254,9 @@ void notifyIdleGcDone(bool force_major)
              setRecentActivity(ACTIVITY_DONE_GC);
  #if !defined(PROFILING)
              pauseTimer();
 +#endif
 +#if !defined(THREADED_IDLEGC)
 +            last_idle_gc_time = getProcessElapsedTime();
  #endif
              break;
+         }

rts/IdleGC.h

@@ -10,6 +10,15 @@
  #include "BeginPrivate.h"
 +/* See Note [GC During Idle Time] */
++
 +#if defined(HAVE_PREEMPTION)
 +#define THREADED_IDLEGC
 +#else
 +/* See Note [Idle GC without preemption] */
 +#endif
++
++
  /* Are we in a state where we are want an idle GC to occur?
   * Used in Capability globalWorkToDo() and Schedule scheduleDetectDeadlock.
   */
@@ -21,7 +30,19 @@ void notifyIdleGcActive(void);
  /* Called from schedule(), specifically scheduleDoGC() */
  void notifyIdleGcDone(bool force_major);
 +#if defined(THREADED_IDLEGC)
++
  /* Called from handle_tick() */
  void handleIdleGcTick(void);
 +#else // !defined(THREADED_IDLEGC)
++
 +/* Called from I/O managers before waiting */
 +Time getNextIdleGcDelayTime(void);
++
 +/* Called from I/O managers after waiting */
 +void notifyIdleGcIdle(bool deadlocked);
++
 +#endif
++
  #include "EndPrivate.h"

rts/Timer.c


   }
 #endif
 
+#if defined(THREADED_IDLEGC)
   handleIdleGcTick();
+#endif
 }
 
 void initTimer(void)

rts/posix/Poll.c

@@ -22,12 +22,18 @@
  #include "rts/Time.h"
  #include "RaiseAsync.h"
  #include "Trace.h"
 +#include "IdleGC.h"
  #include "Poll.h"
  #include "RtsSignals.h"
  #include <limits.h>
  #include <errno.h>
++
 +#if !defined(THREADED_IDLEGC)
 +#undef HAVE_DECL_PPOLL // for simplicity, always use poll when !THREADED_IDLEGC
 +#endif
++
  #if defined(HAVE_DECL_PPOLL) && HAVE_DECL_PPOLL == 1
  /* We prefer the ppoll() function if available since it allows more precise
   * timeouts. It is not in the posix standard however and some platforms
@@ -505,6 +511,17 @@ bool awaitCompletedTimeoutsOrIOPoll(CapIOManager *iomgr)
          int timeout_ms = timeoutInMilliseconds(iomgr, wait, now);
  #endif
 +#if !defined(THREADED_IDLEGC)
 +        /* Without threaded idle GC, poll() does not get interrupted for an
 +         * idle GC. Instead we just limit our wait time to the idle gc delay
 +         * time, and if that timeout is reached then we schedule an idle GC
 +         * (see handleTimeoutForIdleGc below).
 +         */
 +        bool any_pending_io = nfds > 0;
 +        int idlegc_status;
 +        adjustTimeoutForIdleGc(any_pending_io, &timeout_ms, &idlegc_status);
 +#endif
++
          /* Check for I/O readiness, possibly waiting. */
  #if defined(HAVE_DECL_PPOLL) && HAVE_DECL_PPOLL == 1
          int res = ppoll(poll_table, nfds, timeout_ns, NULL);
@@ -533,6 +550,9 @@ bool awaitCompletedTimeoutsOrIOPoll(CapIOManager *iomgr)
  #else
              ASSERT(timeout_ms != -1);
  #endif
 +#if !defined(THREADED_IDLEGC)
 +            handleIdleGcTimeout(idlegc_status, &interrupt);
 +#endif
          } else if (res > 0) {
              int ncompletions = res;

rts/posix/Timeout.c

@@ -17,6 +17,7 @@
  #include "Timeout.h"
  #include "IOManagerInternals.h"
  #include "TimeoutQueue.h"
 +#include "IdleGC.h"
  #include <limits.h>
@@ -135,7 +136,8 @@ static void notifyTimeoutCompletion(CapIOManager *iomgr, StgTimeout *timeout)
  /* poll() expect a timeout in milliseconds, with special
   * values of -1 for indefinite wait, and 0 for no waiting.
   */
 -#if !(defined(HAVE_DECL_PPOLL) && HAVE_DECL_PPOLL == 1)
 +#if !(defined(HAVE_DECL_PPOLL) && HAVE_DECL_PPOLL == 1) \
 + || !defined(THREADED_IDLEGC)
  int timeoutInMilliseconds(CapIOManager *iomgr, bool wait, Time now)
+ {
      if (!wait) {
@@ -220,5 +222,56 @@ struct timespec *timeoutInNanoseconds(CapIOManager *iomgr, bool wait,
+ }
  #endif
 +#if !defined(THREADED_IDLEGC)
 +enum {
 +    timeout_is_idlegc_delay   = 1 << 0,
 +    system_must_be_deadlocked = 1 << 1
 +};
++
 +/* Utilities for handling the non-threaded idle GC variation.
 + *
 + * See Note [Idle GC without preemption]
 + *
 + * Before calling poll()/select() etc, adjust the timeout to account for the
 + * idle GC delay time.
 + *
 + * If the timeout occurs, call handleIdleGcTimeout, which will schedule an idle
 + * GC if the timeout was reached.
 + *
 + * The idlegc_status must be passed from adjustTimeoutForIdleGc to
 + * handleIdleGcTimeout.
 + */
 +void adjustTimeoutForIdleGc(bool any_pending_io,
 +                            int *timeout_ms      /* in/out */,
 +                            int *idlegc_status   /* out */)
 +{
 +    int idlegc_delay_ms = TimeToMS(getNextIdleGcDelayTime());
++
 +    if (RTS_UNLIKELY(!any_pending_io && *timeout_ms == -1)) {
 +        /* We must be deadlocked. Schedule an idle GC unconditionally. */
 +        *timeout_ms    = 0; /* Cause poll() to return res == 0 immediately. */
 +        *idlegc_status = timeout_is_idlegc_delay
 +                       & system_must_be_deadlocked;
++
 +    } else if (RTS_UNLIKELY(RtsFlags.GcFlags.doIdleGC &&
 +                 (idlegc_delay_ms < *timeout_ms || *timeout_ms == -1))) {
 +        /* The idle GC delay will be the next timeout. */
 +        *timeout_ms    = idlegc_delay_ms;
 +        *idlegc_status = timeout_is_idlegc_delay;
++
 +    } else {
 +        *idlegc_status = 0;
 +    }
 +}
++
 +void handleIdleGcTimeout(int idlegc_status, bool *interrupt)
 +{
 +    if (idlegc_status & timeout_is_idlegc_delay) {
 +        notifyIdleGcIdle(idlegc_status & system_must_be_deadlocked);
 +        *interrupt = true;
 +    }
 +}
 +#endif
++
  #endif // defined(IOMGR_ENABLED_POLL)

rts/posix/Timeout.h

@@ -33,7 +33,8 @@ void processTimeoutCompletions(CapIOManager *iomgr, Time now);
   * timeout in milliseconds, with special values of -1 for indefinite wait,
   * and 0 for no waiting.
   */
 -#if !(defined(HAVE_DECL_PPOLL) && HAVE_DECL_PPOLL == 1)
 +#if !(defined(HAVE_DECL_PPOLL) && HAVE_DECL_PPOLL == 1) \
 + || !defined(THREADED_IDLEGC)
  int timeoutInMilliseconds(CapIOManager *iomgr, bool wait, Time now);
  #endif
@@ -46,5 +47,17 @@ struct timespec *timeoutInNanoseconds(CapIOManager *iomgr, bool wait,
                                        Time now, struct timespec *tv);
  #endif
 +#if !defined(THREADED_IDLEGC)
 +/* Utilities for handling the non-threaded idle GC variation.
 + *
 + * See Note [Idle GC without preemption]
 + */
 +void adjustTimeoutForIdleGc(bool any_pending_io,
 +                            int *timeout_ms      /* in/out */,
 +                            int *idlegc_status   /* out */);
++
 +void handleIdleGcTimeout(int idlegc_status, bool *interrupt);
 +#endif
++
  #include "EndPrivate.h"

...	...	@@ -68,7 +68,9 @@ handle_tick(int unused STG_UNUSED)
68	68	}
69	69	#endif
70	70
	71	+#if defined(THREADED_IDLEGC)
71	72	handleIdleGcTick();
	73	+#endif
72	74	}
73	75
74	76	void initTimer(void)