All synchronization objects have names. Names can be used to help
debugging: although there is still no way to get information on what a
thread is up to (like the PROCESS-WHOSTATE in some implementations) this
will probably be added in the future. The name mechanism is currently
used by some implementations. I now think that this is not the right way
to do it, for at least to reasons:
* (minor reason) a thread can be acquiring a lock, or waiting on a
condition variable, or passing a barrier, etc., in several different
places. With the name, this cannot be discerned: a thread can be
deadlocked in one of many different places.
* (major reason) imagine you build some abstractions over SSC, like
monitors, bounded-buffer, etc. These will be implemented with locks and
condition variables, etc. If a thread is blocked because a bounded
buffer is full, the 'whostate' of the process will be something like
"Blocked on lock 'buffers's lock'", instead of something more reasonable
like "Adding client to buffer".
So, what if we drop names from all synchronization objects and instead
add a &key argument to all function that can block? Basically, I'm
proposing taking the approach of PROCESS-WAIT of some implementations,
that accepts a whostate argument, and extend it to all functions that
can block.
We would then have code user like:
(with-lock (mutex :info "Mutual exclusion to list of clients")
(loop while (list-full-p list)
do (condvar-wait cv :info "List of clients is full"))
...)
and code built on a bounded-buffer implemented on SSC:
(put process-bbuffer client :info "Add client for process buffer")
Please comment.
Cheers,
Marco
