Re: Interrupts vs signals

On 19/11/2024 06:09, Thomas Munro wrote:
> It looks like maybeSleepingOnInterrupts replaces maybe_sleeping, and
> SendInterrupt() would need to read it to suppress needless kill()
> calls, but doesn't yet, or am I missing something?

Ah yes, you're right.

> Hmm, I think there are two kinds of kill() suppression that are
> missing compared to master:
> 
> 1.  No wakeup is needed if the bit is already set:
> 
>   SendInterrupt(InterruptType reason, ProcNumber pgprocno)
>   {
>          PGPROC     *proc;
> +       uint32          old_interrupts;
> 
>          Assert(pgprocno != INVALID_PROC_NUMBER);
>          Assert(pgprocno >= 0);
>          Assert(pgprocno < ProcGlobal->allProcCount);
> 
>          proc = &ProcGlobal->allProcs[pgprocno];
> -       pg_atomic_fetch_or_u32(&proc->pendingInterrupts, 1 << reason);
> -       WakeupOtherProc(proc);
> +       old_interrupts =
> pg_atomic_fetch_or_u32(&proc->pendingInterrupts, 1 << reason);
> +       if ((old_interrupts & (1 << reason)) == 0)
> +               WakeupOtherProc(proc);
>   }
> 
> That's equivalent to this removed latch code:
> 
> -       /* Quick exit if already set */
> -       if (latch->is_set)
> -               return;
> 
> ... except it's atomic, which I find a lot easier to think about.

+1

> 2.  Would it make sense to use a bit in pendingInterrupts as a
> replacement for the old maybe_sleeping flag?  (Similar to typical
> implementation of mutexes and other such things, where you adjust the
> lock and atomically know whether you have to wake anyone.)  Then we we
> could easily extend the check above to test that at the same time,
> with the same simple race-free atomic goodness:
> 
> +       if ((old_interrupts & (WAKEME | (1 << reason))) == WAKEME)
> +               WakeupOtherProc(proc);
> 
> I think the waiting side would also be tidier and simpler than what
> you have: you could use atomic_fetch_or to announce you're about to
> sleep, while atomically reading the interrupt bits already set up to
> that moment.

Hmm, so this would replace the maybeSleepingOnInterrupts bitmask I 
envisioned. Makes a lot of sense. If it's a single bit though, that 
means that you'll still get woken up by interrupts that you're not 
waiting for. Maybe that's fine. Or we could merge the 
maybeSleepingOnInterrupts and pendingInterrupts bitmasks to a single 
atomic word, so that you would have a separate "maybe sleeping" bit for 
each interrupt bit, but could still use atomic_fetch_or atomically read 
the interrupt bits and announce the sleeping.

-- 
Heikki Linnakangas
Neon (https://neon.tech)