GitLab

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

Commits:

05b91257

by Duncan Coutts at 2026-09-02T09:31:58+01:00

Move idle GC tracking to its own file, step 1 of 2

Add a new IdleGC.{c,h} module. Move the RecentActivity type,
recent_activity variable and {get,set}RecentActivity wrappers.

2658aba3

by Duncan Coutts at 2026-09-02T09:40:58+01:00

Move idle GC functionality to its own file, step 2 of 2

We can now fully encapsulate the recent_activity state, exposing just
three hooks, and one query used in the scheduler and timer tick.

This is a prelude to making changes to the implementation of tracking
when to perform an idle gc.

5d11c6ff

by Duncan Coutts at 2026-09-02T19:11:54+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.

10 changed files:

rts/Capability.c
+ rts/IdleGC.c
+ rts/IdleGC.h
rts/Schedule.c
rts/Schedule.h
rts/Timer.c
rts/posix/Poll.c
rts/posix/Timeout.c
rts/posix/Timeout.h
rts/rts.cabal

Changes:

rts/Capability.c

@@ -31,6 +31,7 @@
  #include "sm/OSMem.h"
  #include "sm/BlockAlloc.h" // for countBlocks()
  #include "IOManager.h"
 +#include "IdleGC.h"
  #include <string.h>
@@ -88,7 +89,7 @@ STATIC_INLINE bool
  globalWorkToDo (void)
+ {
      return getSchedState() >= SCHED_INTERRUPTING
 -      || getRecentActivity() == ACTIVITY_INACTIVE; // need to check for deadlock
 +        || isIdleGcPending();
+ }
  #endif

rts/IdleGC.c

 +/* -----------------------------------------------------------------------------
 + *
 + * (c) The GHC Team, 1995-2005
 + *
 + * Idle GC: tracking of when to perform a GC during idle time.
 + *
 + * ---------------------------------------------------------------------------*/
++
 +#include "rts/PosixSource.h"
 +#include "Rts.h"
++
 +#include "IdleGC.h"
 +#include "Timer.h"
 +#include "Schedule.h"
++
 +/*
 + Note [GC During Idle Time]
 + ~~~~~~~~~~~~~~~~~~~~~~~~~~
 + A major GC can be performed during idle time (i.e. when no Haskell threads
 + are ready to run).  This can be beneficial for two reasons.  First, running
 + the GC during idle time makes it less likely that a GC will be triggered when
 + the process is active, increasing apparent responsiveness. Second, these idle
 + time GCs allow finalizers to run, preventing resources from being held
 + indefinitely when the process is otherwise idle for extended periods.
++
 + There are two runtime RTS options to control idle time GC timing.  The primary
 + control is set by `-I<n>`, which specifies the minimum period of time the
 + process must be idle before a GC is automatically triggered.  It defaults to
 + 0.3 seconds for the threaded runtime and 0 (which disables idle GC entirely)
 + for the non-threaded runtime.  For certain workflows, the 0.3 second delay for
 + the threaded RTS may be too small.  If an application must process an extended
 + burst of short-lived requests occurring a couple of times a second, it may go
 + idle for >0.3 seconds frequently, resulting in potentially dozens of major
 + GCs triggered every minute (and resulting heavy CPU load) while the burst
 + lasts.  Setting the `-I<n>` value higher will prevent this flurry of major GCs,
 + though there is a danger that setting the value too high will prevent automatic
 + GCs entirely, if the process never gets a chance to go idle for long enough to
 + meet the larger threshold.
++
 + In this case, the second control, set by `-Iw<n>` may be helpful.  For example,
 + setting `-I0.3 -Iw30` triggers automatic GCs after only 0.3 seconds of idle
 + time, but subject to a minimum delay *between* automatic GCs of at least 30
 + seconds.  This is likely to work well for applications that must process a
 + nearly constant stream of frequent, short-lived requests, ensuring that
 + automatic GCs are triggered promptly when the process goes idle while limiting
 + the overall frequency of such GCs.  (The default is `-Iw0`, meaning no limit on
 + frequency of GCs.)
++
 + Automatic GC timing is implemented below using two count-down timers.  The
 + `idle_ticks_to_gc` timer counts down the `-I<n>` setting: it is initialized
 + when the process goes idle and counts down idle time before an automatic GC
 + becomes possible.  The `inter_gc_ticks_to_gc` counts down the `-Iw<n>` setting:
 + it is initialized when an automatic GC is actually performed, and holds off the
 + next automatic GC until its count expires, limiting the overall frequency of
 + automatic GCs.  Both timers must expire before an automatic GC is triggered.
++
 + See issue #11134 for additional detail.
++
 + See also Note [Deadlock detection].
 +*/
++
++
 +/* Flag that tracks whether we have done any execution in this time
 + * slice, and controls the disabling of the interval timer.
 + *
 + * The timer interrupt transitions ACTIVITY_YES into
 + * ACTIVITY_MAYBE_NO, waits for RtsFlags.GcFlags.idleGCDelayTime,
 + * and then:
 + *   - if idle GC is on, set ACTIVITY_INACTIVE and wakeUpRts()
 + *   - if idle GC is off, set ACTIVITY_DONE_GC and stopTimer()
 + *
 + * If the scheduler finds ACTIVITY_INACTIVE, then it sets
 + * ACTIVITY_DONE_GC, performs the GC and calls stopTimer().
 + *
 + * If the scheduler finds ACTIVITY_DONE_GC and it has a thread to run,
 + * it enables the timer again with startTimer().
 + */
 +enum RecentActivity {
 +    // the RTS is active
 +    ACTIVITY_YES      = 0,
 +    // no activity since the last timer signal
 +    ACTIVITY_MAYBE_NO = 1,
 +    // RtsFlags.GcFlags.idleGCDelayTime has passed with no activity
 +    ACTIVITY_INACTIVE = 2,
 +    // like ACTIVITY_INACTIVE, but we've done a GC too (if idle GC is
 +    // enabled) and the interval timer is now turned off.
 +    ACTIVITY_DONE_GC  = 3,
 +};
++
 +/* Recent activity flag.
 + *
 + * Note we must always use atomic operations for it, even in the non-threaded
 + * runtime, since the timer tick runs in a separate thread.
 + *
 + * We don't need an initIdleGc. All it would do is set
 + * recent_activity = ACTIVITY_YES; which we can do statically.
 + */
 +StgWord recent_activity = ACTIVITY_YES;
++
 +static inline enum RecentActivity
 +setRecentActivity(enum RecentActivity new_value)
 +{
 +    StgWord old = SEQ_CST_XCHG_ALWAYS((StgPtr) &recent_activity, (StgWord) new_value);
 +    return (enum RecentActivity) old;
 +}
++
 +static inline enum RecentActivity
 +getRecentActivity(void)
 +{
 +    return (enum RecentActivity) RELAXED_LOAD_ALWAYS(&recent_activity);
 +}
++
 +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;
++
 +/* - countdown for minimum time *between* idle GCs (set by -Iw) */
 +static int inter_gc_ticks_to_gc = 0;
++
 +/*
 + * Called from handle_tick().
 + */
 +void handleIdleGcTick(void)
 +{
 +  /*
 +   * If we've been inactive for idleGCDelayTime (set by +RTS
 +   * -I), tell the scheduler to wake up and do a GC, to check
 +   * for threads that are deadlocked.  However, ensure we wait
 +   * at least interIdleGCWait (+RTS -Iw) between idle GCs.
 +   */
 +  switch (getRecentActivity()) {
 +  case ACTIVITY_YES:
 +      setRecentActivity(ACTIVITY_MAYBE_NO);
 +      idle_ticks_to_gc = RtsFlags.GcFlags.idleGCDelayTime /
 +                         RtsFlags.MiscFlags.tickInterval;
 +      break;
 +  case ACTIVITY_MAYBE_NO:
 +      if (idle_ticks_to_gc == 0 && inter_gc_ticks_to_gc == 0) {
 +          if (RtsFlags.GcFlags.doIdleGC) {
 +              setRecentActivity(ACTIVITY_INACTIVE);
 +              inter_gc_ticks_to_gc = RtsFlags.GcFlags.interIdleGCWait /
 +                                     RtsFlags.MiscFlags.tickInterval;
 +              wakeUpRts();
 +              // The scheduler will call pauseTimer() when it has done
 +              // the GC.
 +          } else {
 +              setRecentActivity(ACTIVITY_DONE_GC);
 +              // disable timer signals (see #1623, #5991, #9105)
 +              // but only if we're not profiling (e.g. passed -h or -p RTS
 +              // flags). If we are profiling we need to keep the timer active
 +              // so that samples continue to be collected.
 +#if defined(PROFILING)
 +              if (!(RtsFlags.ProfFlags.doHeapProfile
 +                    || RtsFlags.CcFlags.doCostCentres)) {
 +                  pauseTimer();
 +              }
 +#else
 +              pauseTimer();
 +#endif
 +          }
 +      } else {
 +          if (idle_ticks_to_gc) idle_ticks_to_gc--;
 +          if (inter_gc_ticks_to_gc) inter_gc_ticks_to_gc--;
 +      }
 +      break;
 +  default:
 +      break;
 +  }
 +}
++
 +#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 = -TIME_MAX;
++
 +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())
 +    {
 +    case ACTIVITY_DONE_GC: {
 +        // ACTIVITY_DONE_GC means we turned off the timer signal to
 +        // conserve power (see #1623).  Re-enable it here.
 +        uint32_t prev;
 +        prev = setRecentActivity(ACTIVITY_YES);
 +        if (prev == ACTIVITY_DONE_GC) {
 +#if !defined(PROFILING)
 +            unpauseTimer();
 +#endif
 +        }
 +        break;
 +    }
 +    case ACTIVITY_INACTIVE:
 +        // If we reached ACTIVITY_INACTIVE, then don't reset it until
 +        // we've done the GC.  The thread running here might just be
 +        // the IO manager thread that handle_tick() woke up via
 +        // wakeUpRts().
 +        break;
 +    default:
 +        setRecentActivity(ACTIVITY_YES);
 +    }
 +}
++
 +void notifyIdleGcDone(bool force_major)
 +{
 +    switch (getRecentActivity()) {
 +    case ACTIVITY_INACTIVE:
 +        if (force_major) {
 +            // We are doing a GC because the system has been idle for a
 +            // timeslice and we need to check for deadlock.  Record the
 +            // fact that we've done a GC and turn off the timer signal;
 +            // it will get re-enabled if we run any threads after the GC.
 +            setRecentActivity(ACTIVITY_DONE_GC);
 +#if !defined(PROFILING)
 +            pauseTimer();
 +#endif
 +#if !defined(THREADED_IDLEGC)
 +            last_idle_gc_time = getProcessElapsedTime();
 +#endif
 +            break;
 +        }
 +        // fall through...
++
 +    case ACTIVITY_MAYBE_NO:
 +        // the GC might have taken long enough for the timer to set
 +        // recent_activity = ACTIVITY_MAYBE_NO or ACTIVITY_INACTIVE,
 +        // but we aren't necessarily deadlocked:
 +        setRecentActivity(ACTIVITY_YES);
 +        break;
++
 +    case ACTIVITY_DONE_GC:
 +        // If we are actually active, the scheduler will reset the
 +        // recent_activity flag and re-enable the timer.
 +        break;
 +    case ACTIVITY_YES:
 +        break;
 +    }
 +}

rts/IdleGC.h

 +/* -----------------------------------------------------------------------------
 + *
 + * (c) The GHC Team, 1995-2005
 + *
 + * Idle GC: tracking of when to perform a GC during idle time.
 + *
 + * Interacts closely with the scheduler and timer tick.
 + *
 + * ---------------------------------------------------------------------------*/
++
 +#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.
 + */
 +bool isIdleGcPending(void);
++
 +/* Called from schedule() */
 +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/Schedule.c

@@ -42,6 +42,7 @@
  #include "Threads.h"
  #include "Timer.h"
  #include "Ticker.h"
 +#include "IdleGC.h"
  #include "ThreadPaused.h"
  #include "ThreadLabels.h"
  #include "Messages.h"
@@ -84,14 +85,6 @@ uint64_t allocated_bytes_at_heapoverflow = 0;
   */
  bool heap_overflow = false;
 -/* flag that tracks whether we have done any execution in this time slice.
 - * LOCK: currently none, perhaps we should lock (but needs to be
 - * updated in the fast path of the scheduler).
 - *
 - * NB. must be StgWord, we do xchg() on it.
 - */
 -StgWord recent_activity = ACTIVITY_YES;
+-
  /* if this flag is set as well, give up execution
   * LOCK: none (changes monotonically)
   */
@@ -437,29 +430,8 @@ run_thread:
      dirty_TSO(cap,t);
      dirty_STACK(cap,t->stackobj);
 -    switch (getRecentActivity())
 -    {
 -    case ACTIVITY_DONE_GC: {
 -        // ACTIVITY_DONE_GC means we turned off the timer signal to
 -        // conserve power (see #1623).  Re-enable it here.
 -        uint32_t prev;
 -        prev = setRecentActivity(ACTIVITY_YES);
 -        if (prev == ACTIVITY_DONE_GC) {
 -#if !defined(PROFILING)
 -            unpauseTimer();
 -#endif
 -        }
 -        break;
 -    }
 -    case ACTIVITY_INACTIVE:
 -        // If we reached ACTIVITY_INACTIVE, then don't reset it until
 -        // we've done the GC.  The thread running here might just be
 -        // the IO manager thread that handle_tick() woke up via
 -        // wakeUpRts().
 -        break;
 -    default:
 -        setRecentActivity(ACTIVITY_YES);
 -    }
 +    // Let the idle gc tracker know that we're running a thread again
 +    notifyIdleGcActive();
      traceEventRunThread(cap, t);
@@ -986,7 +958,7 @@ static void
  scheduleDetectDeadlock (Capability **pcap, Task *task)
+ {
      /* See Note [Deadlock detection] */
 -    if (getRecentActivity() == ACTIVITY_INACTIVE) {
 +    if (isIdleGcPending()) {
          debugTrace(DEBUG_sched, "maybe deadlocked, forcing major GC...");
@@ -1933,35 +1905,7 @@ delete_threads_and_gc:
      traceSparkCounters(cap);
 -    switch (getRecentActivity()) {
 -    case ACTIVITY_INACTIVE:
 -        if (force_major) {
 -            // We are doing a GC because the system has been idle for a
 -            // timeslice and we need to check for deadlock.  Record the
 -            // fact that we've done a GC and turn off the timer signal;
 -            // it will get re-enabled if we run any threads after the GC.
 -            setRecentActivity(ACTIVITY_DONE_GC);
 -#if !defined(PROFILING)
 -            pauseTimer();
 -#endif
 -            break;
 -        }
 -        // fall through...
+-
 -    case ACTIVITY_MAYBE_NO:
 -        // the GC might have taken long enough for the timer to set
 -        // recent_activity = ACTIVITY_MAYBE_NO or ACTIVITY_INACTIVE,
 -        // but we aren't necessarily deadlocked:
 -        setRecentActivity(ACTIVITY_YES);
 -        break;
+-
 -    case ACTIVITY_DONE_GC:
 -        // If we are actually active, the scheduler will reset the
 -        // recent_activity flag and re-enable the timer.
 -        break;
 -    case ACTIVITY_YES:
 -        break;
 -    }
 +    notifyIdleGcDone(force_major);
  #if defined(THREADED_RTS)
      // Stable point where we can do a global check on our spark counters
@@ -2788,8 +2732,6 @@ void
  initScheduler(void)
+ {
    setSchedState(SCHED_RUNNING);
 -  setRecentActivity(ACTIVITY_YES);
+-
    /* Initialise the mutex and condition variables used by
     * the scheduler. */

rts/Schedule.h

@@ -80,58 +80,6 @@ INLINE_HEADER enum SchedState getSchedState(void)
      return (enum SchedState) SEQ_CST_LOAD_ALWAYS(&sched_state);
+ }
 -/*
 - * flag that tracks whether we have done any execution in this time
 - * slice, and controls the disabling of the interval timer.
 - *
 - * The timer interrupt transitions ACTIVITY_YES into
 - * ACTIVITY_MAYBE_NO, waits for RtsFlags.GcFlags.idleGCDelayTime,
 - * and then:
 - *   - if idle GC is on, set ACTIVITY_INACTIVE and wakeUpRts()
 - *   - if idle GC is off, set ACTIVITY_DONE_GC and stopTimer()
 - *
 - * If the scheduler finds ACTIVITY_INACTIVE, then it sets
 - * ACTIVITY_DONE_GC, performs the GC and calls stopTimer().
 - *
 - * If the scheduler finds ACTIVITY_DONE_GC and it has a thread to run,
 - * it enables the timer again with startTimer().
 - */
 -enum RecentActivity {
 -    // the RTS is active
 -    ACTIVITY_YES      = 0,
 -    // no activity since the last timer signal
 -    ACTIVITY_MAYBE_NO = 1,
 -    // RtsFlags.GcFlags.idleGCDelayTime has passed with no activity
 -    ACTIVITY_INACTIVE = 2,
 -    // like ACTIVITY_INACTIVE, but we've done a GC too (if idle GC is
 -    // enabled) and the interval timer is now turned off.
 -    ACTIVITY_DONE_GC  = 3,
 -};
+-
 -/* Recent activity flag.
 - * Locks required  : Transition from MAYBE_NO to INACTIVE
 - * happens in the timer signal, so it is atomic.  Transition from
 - * INACTIVE to DONE_GC happens under sched_mutex.  No lock required
 - * to set it to ACTIVITY_YES.
 - *
 - * N.B. we must always use atomics here since even in the non-threaded runtime
 - * the timer may be provided via a signal.
 - */
 -extern StgWord recent_activity;
+-
 -INLINE_HEADER enum RecentActivity
 -setRecentActivity(enum RecentActivity new_value)
 -{
 -    StgWord old = SEQ_CST_XCHG_ALWAYS((StgPtr) &recent_activity, (StgWord) new_value);
 -    return (enum RecentActivity) old;
 -}
+-
 -INLINE_HEADER enum RecentActivity
 -getRecentActivity(void)
 -{
 -    return (enum RecentActivity) RELAXED_LOAD_ALWAYS(&recent_activity);
 -}
+-
  extern bool heap_overflow;
  #if defined(THREADED_RTS)

rts/Timer.c

@@ -22,7 +22,7 @@
  #include "Timer.h"
  #include "Proftimer.h"
 -#include "Schedule.h"
 +#include "IdleGC.h"
  #include "Ticker.h"
  #include "Capability.h"
  #include "RtsSignals.h"
@@ -37,57 +37,6 @@ static int ticks_to_eventlog_flush = 0;
  #endif
 -/*
 - Note [GC During Idle Time]
 - ~~~~~~~~~~~~~~~~~~~~~~~~~~
 - In the threaded RTS, a major GC can be performed during idle time (i.e., when
 - no Haskell computations are ready to run).  This can be beneficial for two
 - reasons.  First, running the GC during idle time makes it less likely that a GC
 - will be triggered when the process is active, increasing apparent
 - responsiveness.  Second, these idle time GCs allow finalizers to run,
 - preventing resources from being held indefinitely when the process is otherwise
 - idle for extended periods.
+-
 - There are two runtime RTS options to control idle time GC timing.  The primary
 - control is set by `-I<n>`, which specifies the minimum period of time the
 - process must be idle before a GC is automatically triggered.  It defaults to
 - 0.3 seconds for the threaded runtime and 0 (which disables idle GC entirely)
 - for the non-threaded runtime.  For certain workflows, the 0.3 second delay for
 - the threaded RTS may be too small.  If an application must process an extended
 - burst of short-lived requests occurring a couple of times a second, it may go
 - idle for >0.3 seconds frequently, resulting in potentially dozens of major
 - GCs triggered every minute (and resulting heavy CPU load) while the burst
 - lasts.  Setting the `-I<n>` value higher will prevent this flurry of major GCs,
 - though there is a danger that setting the value too high will prevent automatic
 - GCs entirely, if the process never gets a chance to go idle for long enough to
 - meet the larger threshold.
+-
 - In this case, the second control, set by `-Iw<n>` may be helpful.  For example,
 - setting `-I0.3 -Iw30` triggers automatic GCs after only 0.3 seconds of idle
 - time, but subject to a minimum delay *between* automatic GCs of at least 30
 - seconds.  This is likely to work well for applications that must process a
 - nearly constant stream of frequent, short-lived requests, ensuring that
 - automatic GCs are triggered promptly when the process goes idle while limiting
 - the overall frequency of such GCs.  (The default is `-Iw0`, meaning no limit on
 - frequency of GCs.)
+-
 - Automatic GC timing is implemented below using two count-down timers.  The
 - `idle_ticks_to_gc` timer counts down the `-I<n>` setting: it is initialized
 - when the process goes idle and counts down idle time before an automatic GC
 - becomes possible.  The `inter_gc_ticks_to_gc` counts down the `-Iw<n>` setting:
 - it is initialized when an automatic GC is actually performed, and holds off the
 - next automatic GC until its count expires, limiting the overall frequency of
 - automatic GCs.  Both timers must expire before an automatic GC is triggered.
+-
 - See issue #11134 for additional detail.
 -*/
+-
 -/* - countdown for minimum idle time before we start a GC (set by -I) */
 -static int idle_ticks_to_gc = 0;
+-
 -/* - countdown for minimum time *between* idle GCs (set by -Iw) */
 -static int inter_gc_ticks_to_gc = 0;
+-
  /*
   * Function: handle_tick()
+  *
@@ -119,50 +68,9 @@ handle_tick(int unused STG_UNUSED)
+   }
  #endif
 -  /*
 -   * If we've been inactive for idleGCDelayTime (set by +RTS
 -   * -I), tell the scheduler to wake up and do a GC, to check
 -   * for threads that are deadlocked.  However, ensure we wait
 -   * at least interIdleGCWait (+RTS -Iw) between idle GCs.
 -   */
 -  switch (getRecentActivity()) {
 -  case ACTIVITY_YES:
 -      setRecentActivity(ACTIVITY_MAYBE_NO);
 -      idle_ticks_to_gc = RtsFlags.GcFlags.idleGCDelayTime /
 -                         RtsFlags.MiscFlags.tickInterval;
 -      break;
 -  case ACTIVITY_MAYBE_NO:
 -      if (idle_ticks_to_gc == 0 && inter_gc_ticks_to_gc == 0) {
 -          if (RtsFlags.GcFlags.doIdleGC) {
 -              setRecentActivity(ACTIVITY_INACTIVE);
 -              inter_gc_ticks_to_gc = RtsFlags.GcFlags.interIdleGCWait /
 -                                     RtsFlags.MiscFlags.tickInterval;
 -              wakeUpRts();
 -              // The scheduler will call pauseTimer() when it has done
 -              // the GC.
 -          } else {
 -              setRecentActivity(ACTIVITY_DONE_GC);
 -              // disable timer signals (see #1623, #5991, #9105)
 -              // but only if we're not profiling (e.g. passed -h or -p RTS
 -              // flags). If we are profiling we need to keep the timer active
 -              // so that samples continue to be collected.
 -#if defined(PROFILING)
 -              if (!(RtsFlags.ProfFlags.doHeapProfile
 -                    || RtsFlags.CcFlags.doCostCentres)) {
 -                  pauseTimer();
 -              }
 -#else
 -              pauseTimer();
 +#if defined(THREADED_IDLEGC)
 +  handleIdleGcTick();
  #endif
 -          }
 -      } else {
 -          if (idle_ticks_to_gc) idle_ticks_to_gc--;
 -          if (inter_gc_ticks_to_gc) inter_gc_ticks_to_gc--;
 -      }
 -      break;
 -  default:
 -      break;
 -  }
+ }
  void initTimer(void)

rts/posix/Poll.c

@@ -28,6 +28,11 @@
  #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 +510,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 +549,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"

rts/rts.cabal

@@ -420,6 +420,7 @@ library
                   HsFFI.c
                   Inlines.c
                   Interpreter.c
 +                 IdleGC.c
                   IOManager.c
                   LdvProfile.c
                   Libdw.c