GitLab

Marge Bot pushed to branch master at Glasgow Haskell Compiler / GHC

Commits:

6e381626

by Duncan Coutts at 2026-07-01T22:29:55+01:00

Adjust releaseCapability_ precondition to allow cap->running_task == NULL

There are two use cases for releaseCapability_:

1. The current Task (cap->running_task) releases the Capability.
   The Capability is marked free, and if there is any work to do,
   an appropriate Task is woken up.

2. There is no current task (cap->task == NULL), and thus the
   Capability is idle, and we want to wake up an idle Task to animate
   the Capability. This case uses always_wakeup.

Currently, the precondition for releaseCapability_ is
  cap->running_task != NULL
and so the 2nd use cases have to set cap->running_task (which is then
immediately overwritten) just to satisfy the precondition. See the
use cases in sendMessage and prodCapability.

So we can relax the precondition to be:
  cap->running_task != NULL || always_wakeup
so that in the always_wakeup case, we say it is ok for the
cap->running_task to be NULL.

This lets us simplify sendMessage and prodCapability. In particular it
will allow prodCapability to not need a Task parameter.

The ulterior motive for all this is that I want to be able to call
prodCapability from an OS thread that is not itself a Task, in persuit
of issue #27086: disentangle I/O managers from wakeUpRts. The most
straightforward way to wake the RTS is using prodCapability, but the
context in which we will need to do that are threads that are not Tasks.

89404ebc

by Duncan Coutts at 2026-07-01T22:29:55+01:00

prodCapability no longer needs to take a Task param

Now that releaseCapability_ can accept cap->running_task == NULL then it
is no longer necessary for prodCapability to require a Task.

4e60c5f6

by Duncan Coutts at 2026-07-01T22:29:56+01:00

Define prodOneCapability

There was an existing declaration for this in the header file, but no
definition.

Similarly, there is a declaration for prodAllCapabilities but no
definition, and we don't need it, so remove the declaration.

2527026f

by Duncan Coutts at 2026-07-01T22:29:56+01:00

Add a wakeUpRtsViaTicker feature to the posix ticker

It proxies a call to wakeUpRts, but crucially, this can be called from
a signal handler context. It will be used for ctl-c handling.

aa5a03a5

by Duncan Coutts at 2026-07-01T22:29:56+01:00

Change how wakeUpRts works

Previously it would call wakeupIOManager to get a capability to wake up
and run. This works but it entangles the I/O managers with unrelated
features: ctl-c handling and idle gc (the two features that use wakeUpRts).

The reason it used wakeupIOManager is that this action is safe to use
from a posix signal handler, since it just posts bytes to a pipe.
Otherwise the more direct approach (used e.g. by sendMessage when the
target capability is idle) is to use releaseCapability. But that uses
condition variables and mutexes, which are not safe to use from within a
signal handler.

So instead of entangling the (multiple) I/O managers with this, we make
wakeUpRts use the direct approach (using prodOneCapability). On win32
the ctl-c console handler can call wakeUpRts directly, since it is
called in a proper thread. On posix, to deal with the signal handler
problem, we make the signal handler ask the ticker thread to proxy the
call to wakeUpRts, since the ticker thread is also a proper thread.

This will allow the I/O managers to no longer be concerned with this.
This is good because there are many I/O managers (and they're
complicated), but there is (on posix) only one ticker implementation. So
this is an overall reduction in coupling and complexity.

Fixes issue #27086

Changes:

rts/Capability.c

@@ -525,13 +525,20 @@ giveCapabilityToTask (Capability *cap USED_IF_DEBUG, Task *task)
  /* ----------------------------------------------------------------------------
   * releaseCapability
+  *
 - * The current Task (cap->task) releases the Capability.  The Capability is
 - * marked free, and if there is any work to do, an appropriate Task is woken up.
 + * This serves two purposes:
 + *
 + * 1. The current Task (cap->running_task) releases the Capability.
 + *    The Capability is marked free, and if there is any work to do, an
 + *    appropriate Task is woken up.
 + *
 + * 2. There is no current task (cap->task == NULL), and thus the Capability
 + *    is idle, and we want to wake up an idle Task to animate the Capability.
 + *    In this case set always_wakeup. See also prodCapability.
+  *
   * The caller must hold cap->lock and will still hold it after
   * releaseCapability returns.
+  *
 - * N.B. May need to take all_tasks_mutex.
 + * N.B. May need to take all_tasks_mutex, if it needs to start a new task.
+  *
   * ------------------------------------------------------------------------- */
@@ -540,12 +547,18 @@ void
  releaseCapability_ (Capability* cap,
                      bool always_wakeup)
+ {
 -    Task *task;
+-
 -    task = cap->running_task;
+-
 -    ASSERT_PARTIAL_CAPABILITY_INVARIANTS(cap,task);
 -    ASSERT_RETURNING_TASKS(cap,task);
 +    {
 +        Task *task = cap->running_task;
++
 +        ASSERT(task || always_wakeup);
 +        // To cover purpose 2 above, we allow the cap->running_task to be
 +        // NULL, to handle cases where a thread (that is not itself a Task)
 +        // needs to wake up an idle task for the capability.
 +        if (task) {
 +            ASSERT_PARTIAL_CAPABILITY_INVARIANTS(cap,task);
 +            ASSERT_RETURNING_TASKS(cap,task);
 +        }
 +    }
      ASSERT_LOCK_HELD(&cap->lock);
      RELAXED_STORE(&cap->running_task, NULL);
@@ -581,8 +594,8 @@ releaseCapability_ (Capability* cap,
          // assertion is false: in schedule() we force a yield after
          // ThreadBlocked, but the thread may be back on the run queue
          // by now.
 -        task = peekRunQueue(cap)->bound->task;
 -        giveCapabilityToTask(cap, task);
 +        Task *btask = peekRunQueue(cap)->bound->task;
 +        giveCapabilityToTask(cap, btask);
          return;
+     }
@@ -1087,16 +1100,25 @@ yieldCapability
  #if defined(THREADED_RTS)
  void
 -prodCapability (Capability *cap, Task *task)
 +prodCapability (Capability *cap)
+ {
      ACQUIRE_LOCK(&cap->lock);
      if (!cap->running_task) {
 -        cap->running_task = task;
          releaseCapability_(cap,true);
+     }
      RELEASE_LOCK(&cap->lock);
+ }
 +/* Ensure at least one capability is not idle. Used to wake up the RTS
 + * in cases where we anticipate that all capabilities may be idle. In
 + * particular it is used for the ctl-c handler, and after the idle GC
 + * timeout to initiate idle GC. */
 +void
 +prodOneCapability (void)
 +{
 +    prodCapability(getCapability(0));
 +}
++
  #endif /* THREADED_RTS */
  /* ----------------------------------------------------------------------------

rts/Capability.h

@@ -348,11 +348,7 @@ bool yieldCapability (Capability** pCap, Task *task, bool gcAllowed);
  // need to service some global event.
  //
  void prodOneCapability (void);
 -void prodCapability (Capability *cap, Task *task);
+-
 -// Similar to prodOneCapability(), but prods all of them.
 -//
 -void prodAllCapabilities (void);
 +void prodCapability (Capability *cap);
  // Attempt to gain control of a Capability if it is free.
  //

rts/Messages.c

@@ -49,9 +49,11 @@ void sendMessage(Capability *from_cap, Capability *to_cap, Message *msg)
      recordClosureMutated(from_cap,(StgClosure*)msg);
      if (to_cap->running_task == NULL) {
 -        to_cap->running_task = myTask();
 -            // precond for releaseCapability_()
 -        releaseCapability_(to_cap,false);
 +        /* Precond for releaseCapability_ is: running_task || always_wakeup.
 +         * We have running_task == NULL, hence we must use always_wakeup. This
 +         * is ok since the inbox is now non-empty, so we wake a task anyway.
 +         */
 +        releaseCapability_(to_cap, true /*always_wakeup*/);
      } else {
          interruptCapability(to_cap);
+     }

rts/Schedule.c

@@ -2885,8 +2885,8 @@ performBlockingMajorGC(void)
+ }
  /* ---------------------------------------------------------------------------
 -   Interrupt execution.
 -   Might be called inside a signal handler so it mustn't do anything fancy.
 +   Interrupt execution in response to ctl-c.
 +   On posix, ctl-c is a signal, while on Win32 it is a console event.
     ------------------------------------------------------------------------ */
  void
@@ -2896,17 +2896,37 @@ interruptStgRts(void)
      setSchedState(SCHED_INTERRUPTING);
      interruptAllCapabilities();
  #if defined(THREADED_RTS)
 +    /* It may be that all capabilities are idle. If so, we must wake one up. */
 +#if defined(mingw32_HOST_OS)
 +    /* On win32, console handlers are invoked in a proper thread, so we can
 +     * directly call wakeUpRts. Although it is an OS thread, it is not one
 +     * we created or control necessarily, so it may have no associated Task.
 +     */
      wakeUpRts();
 +#else
 +    /* On posix on the other hand, signal handlers are very limited in what
 +     * they can do. We cannot directly call wakeUpRts below because it is not
 +     * signal safe (it uses cond vars to wake up a task). So instead we proxy
 +     * it: we interrupt the ticker thread and ask the ticker thread to call
 +     * wakeUpRts below. The ticker thread is a proper thread and so can call
 +     * wakeUpRts. We can interrupt the ticker thread from signal handler
 +     * context safely because it only involves writing to a pipe/eventfd.
 +     */
 +    wakeUpRtsViaTicker();
 +#endif
  #endif
+ }
  /* -----------------------------------------------------------------------------
     Wake up the RTS
 -   This function causes at least one OS thread to wake up and run the
 -   scheduler loop.  It is invoked when the RTS might be deadlocked, or
 -   an external event has arrived that may need servicing (eg. a
 -   keyboard interrupt).
 +   This function causes at least one task to wake up and run the scheduler
 +   loop on at least one capability.
++
 +   It is invoked:
 +   1. as part of the idle GC scheme: when the RTS has been idle for long enough
 +      and it is time to go back to the scheduler which will invoke idle GC; or
 +   2. when a ctl-c occurs (posix sigint signal or win32 console event)
     In the single-threaded RTS we don't do anything here; we only have
     one thread anyway, and the event that caused us to want to wake up
@@ -2916,10 +2936,11 @@ interruptStgRts(void)
  #if defined(THREADED_RTS)
  void wakeUpRts(void)
+ {
 -    // This forces the IO Manager thread to wakeup, which will
 -    // in turn ensure that some OS thread wakes up and runs the
 -    // scheduler loop, which will cause a GC and deadlock check.
 -    wakeupIOManager();
 +    /* Our current thread may not have a Task, in particular it will not when
 +     * called from interruptStgRts or via wakeUpRtsViaTicker. This is ok,
 +     * prodOneCapability does not require one.
 +     */
 +    prodOneCapability();
+ }
  #endif

rts/Ticker.h

@@ -52,4 +52,8 @@ void exitTicker(void);
  void pauseTicker(void);
  void unpauseTicker(void);
 +#if defined(THREADED_RTS)
 +void wakeUpRtsViaTicker(void);
 +#endif
++
  #include "EndPrivate.h"

rts/posix/Ticker.c

@@ -127,6 +127,13 @@ static Time ticker_interval = DEFAULT_TICK_INTERVAL;
  // acknowledgement.
  static bool pause_request;
 +#if defined(THREADED_RTS)
 +// Atomic variable used by the ctl-c handler (posix signal handler) to
 +// communicate that the ticker thread should wake up the rts. This
 +// communication is one-way, with no acknowledgement.
 +static bool interrupt_request;
 +#endif
++
  // Atomic variable used by other threads to communicate that they want the
  // ticker thread to exit.
  static bool exit_request;
@@ -177,6 +184,13 @@ static void *ticker_thread_func(void *_handle_tick)
              paused = ACQUIRE_LOAD_ALWAYS(&pause_request);
              exit   = RELAXED_LOAD_ALWAYS(&exit_request);
++
 +#if defined(THREADED_RTS)
 +            if (RELAXED_LOAD_ALWAYS(&interrupt_request)) {
 +                RELEASE_STORE_ALWAYS(&interrupt_request, false);
 +                wakeUpRts();
 +            }
 +#endif
          } else if (errno != EINTR) {
              // While the RTS attempts to mask signals, some foreign libraries
              // that rely on signal delivery may unmask them. Consequently we
@@ -262,6 +276,14 @@ void pauseTicker(void)
      sendFdWakeup(notifyfd_w);
+ }
 +#if defined(THREADED_RTS)
 +void wakeUpRtsViaTicker(void)
 +{
 +    RELAXED_STORE_ALWAYS(&interrupt_request, true);
 +    sendFdWakeup(notifyfd_w);
 +}
 +#endif
++
  /* Synchronous. Not idempotent.
   * The ticker is guaranteed stopped after this.
   */

rts/sm/GC.c


         for(i = 0; i < getNumCapabilities(); ++i) {
             if (i == me || idle_cap[i]) { continue; }
             if (SEQ_CST_LOAD(&gc_threads[i]->wakeup) != GC_THREAD_STANDING_BY) {
-                prodCapability(getCapability(i), cap->running_task);
+                prodCapability(getCapability(i));
                 interruptCapability(getCapability(i));
             }
         }

...	...	@@ -1522,7 +1522,7 @@ waitForGcThreads (Capability *cap, bool idle_cap[])
1522	1522	for(i = 0; i < getNumCapabilities(); ++i) {
1523	1523	if (i == me \|\| idle_cap[i]) { continue; }
1524	1524	if (SEQ_CST_LOAD(&gc_threads[i]->wakeup) != GC_THREAD_STANDING_BY) {
1525		- prodCapability(getCapability(i), cap->running_task);
	1525	+ prodCapability(getCapability(i));
1526	1526	interruptCapability(getCapability(i));
1527	1527	}
1528	1528	}