Re: exemption-wait question

[Vladimir T. <vtz...@gm...>]

On 11/1/10, Don Cohen <don...@is...> wrote:
> I'm only gradually beginning to understand what exemptions
> are supposed to do.  If my interpretation below is correct then
> perhaps some of it should be added to the doc.
>
> Looking at doc for exemption-wait
>   On return mutex is acquired again.
> This is true even on timeout?
Yes, in all cases. When the control returns from exemption-wait - the
mutex is owned by the thread regardless what caused exemption-wait to
return.

> So you're supposed to do something like this, right?
>  (with-mutext-lock m
>    (if (exemption-wait e m (lambda () <condition>))
>       ;; condition should be something that can only become true/false
>       ;; due to something executed by a thread owning mutex m, right?
yes
>       ;; that's why we expect that evaluating the condition while
>       ;; holding m will not be affected by race conditions
>       (;; now I have the lock and condition is true
>        ...)
>       (;; exemption-wait returns false
>        ;; I have the lock but condition is (probably still) false
>        ;; This can happen only if I supply a timeout?
only on timeout (or on some obscure error but if happens - it is error
in clisp implementation).
>        ;; Or can it occur if this thread is interrupted?
>        ...))
>     )

If thread is interrupted while in exemption-wait the interrupt
function will be executed with mutex held. On non-local exit from the
function - all unwind-protect forms will be executed and mutex in the
above example will be unlocked. In case of normal exit from interrupt
function - exemption-wait will continue to wait.

> Now that I think I understand what exemptions are supposed to mean,
> it occurs to me that they could be implemented in lisp if we only had
> the ability to make a thread schedulable or not.(*)
With native OS preemptive threads - we do not have control on the
scheduler. We may influence it with mutex and exemptions.

> An exemption seems to be mainly a queue of threads waiting for
> something.  While they are waiting they are not schedulable, i.e.,
> they should not run.  Exemption signal and broadcast then simply make
> either the first or all on the queue schedulable (and remove them
> from the queue).
> At the moment I don't see where spurious wakeups would come from.
I've observed spurious wakeups when signals are delivered to the process.

> BTW, it seems to me that there should also be some some way to control
> which of several threads waiting to run should be scheduled next.  Why
> is that either not possible or a bad idea?
Use distinct exemptions for this (and share the mutex if needed).